Linux Cubed Series 4: GNU Archives/Linux Cubed Series 4 - GNU Archives.iso/gnu/cvs-1.8/cvs-1/cvs-1.8.1/src/client.c

C/C++ Source or Header | 1996-05-06 | 108.1 KB | 4,491 lines

/* CVS client-related stuff.  */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif /* HAVE_CONFIG_H */

#include "cvs.h"
#include "getline.h"
#include "edit.h"

#ifdef CLIENT_SUPPORT

#include "md5.h"

#if defined(AUTH_CLIENT_SUPPORT) || HAVE_KERBEROS || USE_DIRECT_TCP
#  ifdef HAVE_WINSOCK_H
#    include <winsock.h>
#  else /* No winsock.h */
#    include <sys/socket.h>
#    include <netinet/in.h>
#    include <netdb.h>
#  endif /* No winsock.h */
#endif /* defined(AUTH_CLIENT_SUPPORT) || HAVE_KERBEROS || USE_DIRECT_TCP */

#ifdef AUTH_CLIENT_SUPPORT
char *get_cvs_password PROTO((char *user, char *host, char *cvsrooot));
#endif /* AUTH_CLIENT_SUPPORT */

#if HAVE_KERBEROS || USE_DIRECT_TCP
#define CVS_PORT 1999

#if HAVE_KERBEROS
#include <krb.h>

extern char *krb_realmofhost ();
#ifndef HAVE_KRB_GET_ERR_TEXT
#define krb_get_err_text(status) krb_err_txt[status]
#endif /* HAVE_KRB_GET_ERR_TEXT */
#endif /* HAVE_KERBEROS */

#endif /* HAVE_KERBEROS || USE_DIRECT_TCP */

static void add_prune_candidate PROTO((char *));

/* All the commands.  */
int add PROTO((int argc, char **argv));
int admin PROTO((int argc, char **argv));
int checkout PROTO((int argc, char **argv));
int commit PROTO((int argc, char **argv));
int diff PROTO((int argc, char **argv));
int history PROTO((int argc, char **argv));
int import PROTO((int argc, char **argv));
int cvslog PROTO((int argc, char **argv));
int patch PROTO((int argc, char **argv));
int release PROTO((int argc, char **argv));
int cvsremove PROTO((int argc, char **argv));
int rtag PROTO((int argc, char **argv));
int status PROTO((int argc, char **argv));
int tag PROTO((int argc, char **argv));
int update PROTO((int argc, char **argv));

/* All the response handling functions.  */
static void handle_ok PROTO((char *, int));
static void handle_error PROTO((char *, int));
static void handle_valid_requests PROTO((char *, int));
static void handle_checked_in PROTO((char *, int));
static void handle_new_entry PROTO((char *, int));
static void handle_checksum PROTO((char *, int));
static void handle_copy_file PROTO((char *, int));
static void handle_updated PROTO((char *, int));
static void handle_merged PROTO((char *, int));
static void handle_patched PROTO((char *, int));
static void handle_removed PROTO((char *, int));
static void handle_remove_entry PROTO((char *, int));
static void handle_set_static_directory PROTO((char *, int));
static void handle_clear_static_directory PROTO((char *, int));
static void handle_set_sticky PROTO((char *, int));
static void handle_clear_sticky PROTO((char *, int));
static void handle_set_checkin_prog PROTO((char *, int));
static void handle_set_update_prog PROTO((char *, int));
static void handle_module_expansion PROTO((char *, int));
static void handle_m PROTO((char *, int));
static void handle_e PROTO((char *, int));
static void handle_notified PROTO((char *, int));

static size_t try_read_from_server PROTO ((char *, size_t));
#endif /* CLIENT_SUPPORT */

#if defined(CLIENT_SUPPORT) || defined(SERVER_SUPPORT)

/* Shared with server.  */

/*
 * Return a malloc'd, '\0'-terminated string
 * corresponding to the mode in SB.
 */
char *
#ifdef __STDC__
mode_to_string (mode_t mode)
#else /* ! __STDC__ */
mode_to_string (mode)
    mode_t mode;
#endif /* __STDC__ */
{
    char buf[18], u[4], g[4], o[4];
    int i;

    i = 0;
    if (mode & S_IRUSR) u[i++] = 'r';
    if (mode & S_IWUSR) u[i++] = 'w';
    if (mode & S_IXUSR) u[i++] = 'x';
    u[i] = '\0';

    i = 0;
    if (mode & S_IRGRP) g[i++] = 'r';
    if (mode & S_IWGRP) g[i++] = 'w';
    if (mode & S_IXGRP) g[i++] = 'x';
    g[i] = '\0';

    i = 0;
    if (mode & S_IROTH) o[i++] = 'r';
    if (mode & S_IWOTH) o[i++] = 'w';
    if (mode & S_IXOTH) o[i++] = 'x';
    o[i] = '\0';

    sprintf(buf, "u=%s,g=%s,o=%s", u, g, o);
    return xstrdup(buf);
}

/*
 * Change mode of FILENAME to MODE_STRING.
 * Returns 0 for success or errno code.
 */
int
change_mode (filename, mode_string)
    char *filename;
    char *mode_string;
{
#ifdef CHMOD_BROKEN
    char *p;
    int writeable = 0;

    /* We can only distinguish between
         1) readable
         2) writeable
         3) Picasso's "Blue Period"
       We handle the first two. */
    p = mode_string;
    while (*p != '\0')
    {
    if ((p[0] == 'u' || p[0] == 'g' || p[0] == 'o') && p[1] == '=')
    {
        char *q = p + 2;
        while (*q != ',' && *q != '\0')
        {
        if (*q == 'w')
            writeable = 1;
        ++q;
        }
    }
    /* Skip to the next field.  */
    while (*p != ',' && *p != '\0')
        ++p;
    if (*p == ',')
        ++p;
    }

    xchmod (filename, writeable);
    return 0;

#else /* ! CHMOD_BROKEN */

    char *p;
    mode_t mode = 0;

    p = mode_string;
    while (*p != '\0')
    {
    if ((p[0] == 'u' || p[0] == 'g' || p[0] == 'o') && p[1] == '=')
    {
        int can_read = 0, can_write = 0, can_execute = 0;
        char *q = p + 2;
        while (*q != ',' && *q != '\0')
        {
        if (*q == 'r')
            can_read = 1;
        else if (*q == 'w')
            can_write = 1;
        else if (*q == 'x')
            can_execute = 1;
        ++q;
        }
        if (p[0] == 'u')
        {
        if (can_read)
            mode |= S_IRUSR;
        if (can_write)
            mode |= S_IWUSR;
        if (can_execute)
            mode |= S_IXUSR;
        }
        else if (p[0] == 'g')
        {
        if (can_read)
            mode |= S_IRGRP;
        if (can_write)
            mode |= S_IWGRP;
        if (can_execute)
            mode |= S_IXGRP;
        }
        else if (p[0] == 'o')
        {
        if (can_read)
            mode |= S_IROTH;
        if (can_write)
            mode |= S_IWOTH;
        if (can_execute)
            mode |= S_IXOTH;
        }
    }
    /* Skip to the next field.  */
    while (*p != ',' && *p != '\0')
        ++p;
    if (*p == ',')
        ++p;
    }

    if (chmod (filename, mode) < 0)
    return errno;
    return 0;
#endif /* ! CHMOD_BROKEN */
}

#endif /* CLIENT_SUPPORT or SERVER_SUPPORT */

#ifdef CLIENT_SUPPORT

/* The host part of CVSROOT.  */
static char *server_host;
/* The user part of CVSROOT */
static char *server_user;
/* The repository part of CVSROOT.  */
static char *server_cvsroot;

int client_active;

int client_prune_dirs;

static int cvsroot_parsed = 0;

static List *ignlist = (List *) NULL;

/* Set server_host and server_cvsroot.  */
static void
parse_cvsroot ()
{
    char *p;
#ifdef AUTH_CLIENT_SUPPORT
    static char *access_method;
#endif /* AUTH_CLIENT_SUPPORT */

    /* Don't go through the trouble twice. */
    if (cvsroot_parsed)
      return;

    server_host = xstrdup (CVSroot);

#ifdef AUTH_CLIENT_SUPPORT
    if ((server_host[0] == ':'))
    {
      /* Access method specified, as in
       * "cvs -d :pserver:user@host:/path".
       * We need to get past that part of CVSroot before parsing the
       * rest of it.
       */
      access_method = p = &(server_host[1]);

      if (! *access_method)
        error (1, 0, "bad CVSroot: %s", CVSroot);

      if (! *(p = strchr (access_method, ':')))
        error (1, 0, "bad CVSroot: %s", CVSroot);

      *p = '\0';
      p++;

      server_host = p;

      if (! *server_host)
        error (1, 0, "bad CVSroot: %s", CVSroot);

      if (strcmp (access_method, "pserver") == 0)
        use_authenticating_server = 1;
      else
        error (1, 0, "unknown access method: %s", access_method);
    }
#endif /* AUTH_CLIENT_SUPPORT */

    /* First get just the pathname. */
    server_cvsroot = strchr (server_host, ':');
    *server_cvsroot = '\0';
    ++server_cvsroot;

    /* Then deal with host and possible user. */
    if ( (p = strchr (server_host, '@')) == NULL)
    {
      server_user = NULL;
    }
    else
    {
      server_user = server_host;
      server_host = p;
      ++server_host;
      *p = '\0';
    }

    client_active = 1;
    cvsroot_parsed = 1;
}

#ifdef NO_SOCKET_TO_FD
/* Under certain circumstances, we must communicate with the server
   via a socket using send() and recv().  This is because under some
   operating systems (OS/2 and Windows 95 come to mind), a socket
   cannot be converted to a file descriptor -- it must be treated as a
   socket and nothing else. */
static int use_socket_style = 0;
static int server_sock;
#endif /* NO_SOCKET_TO_FD */

/* Stream to write to the server.  */
static FILE *to_server;
/* Stream to read from the server.  */
static FILE *from_server;

/* We might want to log client/server traffic. */
static FILE *from_server_logfile;
static FILE *to_server_logfile;

#if ! RSH_NOT_TRANSPARENT
/* Process ID of rsh subprocess.  */
static int rsh_pid = -1;
#endif /* ! RSH_NOT_TRANSPARENT */


/*
 * Read a line from the server.  Result does not include the terminating \n.
 *
 * Space for the result is malloc'd and should be freed by the caller.
 *
 * Returns number of bytes read.  If EOF_OK, then return 0 on end of file,
 * else end of file is an error.
 */
static int
read_line (resultp, eof_ok)
    char **resultp;
    int eof_ok;
{
    int c;
    char *result;
    size_t input_index = 0;
    size_t result_size = 80;

#ifdef NO_SOCKET_TO_FD
    if (! use_socket_style)
#endif /* NO_SOCKET_TO_FD */
      fflush (to_server);

    result = (char *) xmalloc (result_size);

    while (1)
    {

#ifdef NO_SOCKET_TO_FD
      if (use_socket_style)
        {
          char ch;
          /* Yes, this sucks performance-wise.  Short of implementing
             our own buffering, I'm not sure how to effect a big
             improvement.  We could at least avoid calling
             read_from_server() for each character if we were willing
             to duplicate a lot of its code, but I'm not sure that's
             worth it. */
          read_from_server (&ch, 1);
          c = ch;
        }
      else
#endif /* NO_SOCKET_TO_FD */
        c = getc (from_server);

    if (c == EOF)
    {
        free (result);

#ifdef NO_SOCKET_TO_FD
            if (! use_socket_style)
#endif /* NO_SOCKET_TO_FD */
              if (ferror (from_server))
                error (1, errno, "reading from server");

        /* It's end of file.  */
        if (eof_ok)
        return 0;
        else
        error (1, 0, "end of file from server (consult above messages if any)");
    }

    if (c == '\n')
        break;

    result[input_index++] = c;
    while (input_index + 1 >= result_size)
    {
        result_size *= 2;
        result = (char *) xrealloc (result, result_size);
    }
    }

    if (resultp)
    *resultp = result;

    /* Terminate it just for kicks, but we *can* deal with embedded NULs.  */
    result[input_index] = '\0';

#ifdef NO_SOCKET_TO_FD
    if (! use_socket_style)
#endif /* NO_SOCKET_TO_FD */
    {
    /*
     * If we're using socket style, then everything has already
     * been logged because read_from_server() was used to get the
     * individual chars, and read_from_server() logs already.
     */
    if (from_server_logfile)
    {
        if (fwrite (result, 1, input_index, from_server_logfile)
        < input_index)
        error (0, errno, "writing to from-server logfile");
        putc ('\n', from_server_logfile);
    }
    }

    if (resultp == NULL)
    free (result);
    return input_index;
}

#endif /* CLIENT_SUPPORT */


#if defined(CLIENT_SUPPORT) || defined(SERVER_SUPPORT)

/*
 * Zero if compression isn't supported or requested; non-zero to indicate
 * a compression level to request from gzip.
 */
int gzip_level;

int filter_through_gzip (fd, dir, level, pidp)
     int fd, dir, level;
     pid_t *pidp;
{
  static char buf[5] = "-";
  static char *gzip_argv[3] = { "gzip", buf };

  sprintf (buf+1, "%d", level);
  return filter_stream_through_program (fd, dir, &gzip_argv[0], pidp);
}

int filter_through_gunzip (fd, dir, pidp)
     int fd, dir;
     pid_t *pidp;
{
  static char *gunzip_argv[3] = { "gunzip", "-d" };
  return filter_stream_through_program (fd, dir, &gunzip_argv[0], pidp);
}

#endif /* CLIENT_SUPPORT or SERVER_SUPPORT */

#ifdef CLIENT_SUPPORT

/*
 * The Repository for the top level of this command (not necessarily
 * the CVSROOT, just the current directory at the time we do it).
 */
static char *toplevel_repos;

/* Working directory when we first started.  */
char toplevel_wd[PATH_MAX];

static void
handle_ok (args, len)
    char *args;
    int len;
{
    return;
}

static void
handle_error (args, len)
    char *args;
    int len;
{
    int something_printed;

    /*
     * First there is a symbolic error code followed by a space, which
     * we ignore.
     */
    char *p = strchr (args, ' ');
    if (p == NULL)
    {
    error (0, 0, "invalid data from cvs server");
    return;
    }
    ++p;
    len -= p - args;
    something_printed = 0;
    for (; len > 0; --len)
    {
    something_printed = 1;
    putc (*p++, stderr);
    }
    if (something_printed)
    putc ('\n', stderr);
}

static void
handle_valid_requests (args, len)
    char *args;
    int len;
{
    char *p = args;
    char *q;
    struct request *rq;
    do
    {
    q = strchr (p, ' ');
    if (q != NULL)
        *q++ = '\0';
    for (rq = requests; rq->name != NULL; ++rq)
    {
        if (strcmp (rq->name, p) == 0)
        break;
    }
    if (rq->name == NULL)
        /*
         * It is a request we have never heard of (and thus never
         * will want to use).  So don't worry about it.
         */
        ;
    else
    {
        if (rq->status == rq_enableme)
        {
        /*
         * Server wants to know if we have this, to enable the
         * feature.
         */
        send_to_server (rq->name, 0);
                send_to_server ("\012", 0);

        if (!strcmp("UseUnchanged",rq->name))
            use_unchanged = 1;
        }
        else
        rq->status = rq_supported;
    }
    p = q;
    } while (q != NULL);
    for (rq = requests; rq->name != NULL; ++rq)
    {
    if (rq->status == rq_essential)
        error (1, 0, "request `%s' not supported by server", rq->name);
    else if (rq->status == rq_optional)
        rq->status = rq_not_supported;
    }
}

static int use_directory = -1;

static char *get_short_pathname PROTO((const char *));

static char *
get_short_pathname (name)
    const char *name;
{
    const char *retval;
    if (use_directory)
    return (char *) name;
    if (strncmp (name, toplevel_repos, strlen (toplevel_repos)) != 0)
    error (1, 0, "server bug: name `%s' doesn't specify file in `%s'",
           name, toplevel_repos);
    retval = name + strlen (toplevel_repos) + 1;
    if (retval[-1] != '/')
    error (1, 0, "server bug: name `%s' doesn't specify file in `%s'",
           name, toplevel_repos);
    return (char *) retval;
}

/*
 * Do all the processing for PATHNAME, where pathname consists of the
 * repository and the filename.  The parameters we pass to FUNC are:
 * DATA is just the DATA parameter which was passed to
 * call_in_directory; ENT_LIST is a pointer to an entries list (which
 * we manage the storage for); SHORT_PATHNAME is the pathname of the
 * file relative to the (overall) directory in which the command is
 * taking place; and FILENAME is the filename portion only of
 * SHORT_PATHNAME.  When we call FUNC, the curent directory points to
 * the directory portion of SHORT_PATHNAME.  */

static char *last_dir_name;

static void
call_in_directory (pathname, func, data)
    char *pathname;
    void (*func) PROTO((char *data, List *ent_list, char *short_pathname,
              char *filename));
    char *data;
{
    static List *last_entries;

    char *dir_name;
    char *filename;
    /* Just the part of pathname relative to toplevel_repos.  */
    char *short_pathname = get_short_pathname (pathname);
    char *p;

    /*
     * Do the whole descent in parallel for the repositories, so we
     * know what to put in CVS/Repository files.  I'm not sure the
     * full hair is necessary since the server does a similar
     * computation; I suspect that we only end up creating one
     * directory at a time anyway.
     *
     * Also note that we must *only* worry about this stuff when we
     * are creating directories; `cvs co foo/bar; cd foo/bar; cvs co
     * CVSROOT; cvs update' is legitimate, but in this case
     * foo/bar/CVSROOT/CVS/Repository is not a subdirectory of
     * foo/bar/CVS/Repository.
     */
    char *reposname;
    char *short_repos;
    char *reposdirname;
    char *rdirp;
    int reposdirname_absolute;

    reposname = NULL;
    if (use_directory)
    read_line (&reposname, 0);

    reposdirname_absolute = 0;
    if (reposname != NULL)
    {
    if (strncmp (reposname, toplevel_repos, strlen (toplevel_repos)) != 0)
    {
        reposdirname_absolute = 1;
        short_repos = reposname;
    }
    else
    {
        short_repos = reposname + strlen (toplevel_repos) + 1;
        if (short_repos[-1] != '/')
        {
        reposdirname_absolute = 1;
        short_repos = reposname;
        }
    }
    }
    else
    {
    short_repos = short_pathname;
    }
    reposdirname = xstrdup (short_repos);
    p = strrchr (reposdirname, '/');
    if (p == NULL)
    {
    reposdirname = xrealloc (reposdirname, 2);
    reposdirname[0] = '.'; reposdirname[1] = '\0';
    }
    else
    *p = '\0';

    dir_name = xstrdup (short_pathname);
    p = strrchr (dir_name, '/');
    if (p == NULL)
    {
    dir_name = xrealloc (dir_name, 2);
    dir_name[0] = '.'; dir_name[1] = '\0';
    }
    else
    *p = '\0';
    if (client_prune_dirs)
    add_prune_candidate (dir_name);

    filename = strrchr (short_repos, '/');
    if (filename == NULL)
    filename = short_repos;
    else
    ++filename;

    if (reposname != NULL)
    {
    /* This is the use_directory case.  */

    short_pathname = xmalloc (strlen (pathname) + strlen (filename) + 5);
    strcpy (short_pathname, pathname);
    strcat (short_pathname, filename);
    }

    if (last_dir_name == NULL
    || strcmp (last_dir_name, dir_name) != 0)
    {
    if (last_dir_name)
        free (last_dir_name);
    last_dir_name = dir_name;

    if (toplevel_wd[0] == '\0')
        if (getwd (toplevel_wd) == NULL)
        error (1, 0,
               "could not get working directory: %s", toplevel_wd);

    if (chdir (toplevel_wd) < 0)
        error (1, errno, "could not chdir to %s", toplevel_wd);
    if (chdir (dir_name) < 0)
    {
        char *dir;
        char *dirp;

        if (! existence_error (errno))
        error (1, errno, "could not chdir to %s", dir_name);

        /* Directory does not exist, we need to create it.  */
        dir = xmalloc (strlen (dir_name) + 1);
        dirp = dir_name;
        rdirp = reposdirname;

        /* This algorithm makes nested directories one at a time
               and create CVS administration files in them.  For
               example, we're checking out foo/bar/baz from the
               repository:

           1) create foo, point CVS/Repository to <root>/foo
           2)     .. foo/bar                   .. <root>/foo/bar
           3)     .. foo/bar/baz               .. <root>/foo/bar/baz

           As you can see, we're just stepping along DIR_NAME (with
           DIRP) and REPOSDIRNAME (with RDIRP) respectively.

           We need to be careful when we are checking out a
           module, however, since DIR_NAME and REPOSDIRNAME are not
           going to be the same.  Since modules will not have any
           slashes in their names, we should watch the output of
           STRCHR to decide whether or not we should use STRCHR on
           the RDIRP.  That is, if we're down to a module name,
           don't keep picking apart the repository directory name.  */

        do
        {
        dirp = strchr (dirp, '/');
        if (dirp)
          {
            strncpy (dir, dir_name, dirp - dir_name);
            dir[dirp - dir_name] = '\0';
            /* Skip the slash.  */
            ++dirp;
            if (rdirp == NULL)
              error (0, 0,
                 "internal error: repository string too short.");
            else
              rdirp = strchr (rdirp, '/');
          }
        else
          {
            /* If there are no more slashes in the dir name,
                       we're down to the most nested directory -OR- to
                       the name of a module.  In the first case, we
                       should be down to a DIRP that has no slashes,
                       so it won't help/hurt to do another STRCHR call
                       on DIRP.  It will definitely hurt, however, if
                       we're down to a module name, since a module
                       name can point to a nested directory (that is,
                       DIRP will still have slashes in it.  Therefore,
                       we should set it to NULL so the routine below
                       copies the contents of REMOTEDIRNAME onto the
                       root repository directory (does this if rdirp
                       is set to NULL, because we used to do an extra
                       STRCHR call here). */

            rdirp = NULL;
            strcpy (dir, dir_name);
          }

        if (CVS_MKDIR (dir, 0777) < 0)
        {
                  /* Now, let me get this straight.  In IBM C/C++
                   * under OS/2, the error string for EEXIST is:
                   *
                   *     "The file already exists",
                   *
                   * and the error string for EACCESS is:
                   *
                   *     "The file or directory specified is read-only".
                   *
                   * Nonetheless, mkdir() will set EACCESS if the
                   * directory *exists*, according both to the
                   * documentation and its actual behavior.
                   *
                   * I'm sure that this made sense, to someone,
                   * somewhere, sometime.  Just not me, here, now.
                   */
#ifdef EACCESS
                  if ((errno != EACCESS) && (errno != EEXIST))
                    error (1, errno, "cannot make directory %s", dir);
#else /* ! defined(EACCESS) */
                  if ((errno != EEXIST))
                    error (1, errno, "cannot make directory %s", dir);
#endif /* defined(EACCESS) */

                  /* It already existed, fine.  Just keep going.  */
        }
        else if (strcmp (command_name, "export") == 0)
            /* Don't create CVSADM directories if this is export.  */
            ;
        else
        {
            /*
             * Put repository in CVS/Repository.  For historical
             * (pre-CVS/Root) reasons, this is an absolute pathname,
             * but what really matters is the part of it which is
             * relative to cvsroot.
             */
            char *repo;
            char *r;

            repo = xmalloc (strlen (reposdirname)
                    + strlen (toplevel_repos)
                    + 80);
            if (reposdirname_absolute)
            r = repo;
            else
            {
            strcpy (repo, toplevel_repos);
            strcat (repo, "/");
            r = repo + strlen (repo);
            }

            if (rdirp)
            {
            strncpy (r, reposdirname, rdirp - reposdirname);
            r[rdirp - reposdirname] = '\0';
            }
            else
            strcpy (r, reposdirname);

            Create_Admin (dir, dir, repo,
                  (char *)NULL, (char *)NULL);
            free (repo);
        }

        if (rdirp != NULL)
        {
            /* Skip the slash.  */
            ++rdirp;
        }

        } while (dirp != NULL);
        free (dir);
        /* Now it better work.  */
        if (chdir (dir_name) < 0)
        error (1, errno, "could not chdir to %s", dir_name);
    }

    if (strcmp (command_name, "export") != 0)
    {
        if (last_entries)
        Entries_Close (last_entries);
        last_entries = Entries_Open (0);
    }
    }
    else
    free (dir_name);
    free (reposdirname);
    (*func) (data, last_entries, short_pathname, filename);
    if (reposname != NULL)
    {
    free (short_pathname);
    free (reposname);
    }
}

static void
copy_a_file (data, ent_list, short_pathname, filename)
    char *data;
    List *ent_list;
    char *short_pathname;
    char *filename;
{
    char *newname;
#ifdef USE_VMS_FILENAMES
    char *p;
#endif

    read_line (&newname, 0);

#ifdef USE_VMS_FILENAMES
    /* Mogrify the filename so VMS is happy with it. */
    for(p = newname; *p; p++)
       if(*p == '.' || *p == '#') *p = '_';
#endif

    copy_file (filename, newname);
    free (newname);
}

static void
handle_copy_file (args, len)
    char *args;
    int len;
{
    call_in_directory (args, copy_a_file, (char *)NULL);
}


static void read_counted_file PROTO ((char *, char *));

/* Read from the server the count for the length of a file, then read
   the contents of that file and write them to FILENAME.  FULLNAME is
   the name of the file for use in error messages.  FIXME-someday:
   extend this to deal with compressed files and make update_entries
   use it.  On error, gives a fatal error.  */
static void
read_counted_file (filename, fullname)
    char *filename;
    char *fullname;
{
    char *size_string;
    size_t size;
    char *buf;

    /* Pointers in buf to the place to put data which will be read,
       and the data which needs to be written, respectively.  */
    char *pread;
    char *pwrite;
    /* Number of bytes left to read and number of bytes in buf waiting to
       be written, respectively.  */
    size_t nread;
    size_t nwrite;

    FILE *fp;

    read_line (&size_string, 0);
    if (size_string[0] == 'z')
    error (1, 0, "\
protocol error: compressed files not supported for that operation");
    /* FIXME: should be doing more error checking, probably.  Like using
       strtoul and making sure we used up the whole line.  */
    size = atoi (size_string);
    free (size_string);

    /* A more sophisticated implementation would use only a limited amount
       of buffer space (8K perhaps), and read that much at a time.  We allocate
       a buffer for the whole file only to make it easy to keep track what
       needs to be read and written.  */
    buf = xmalloc (size);

    /* FIXME-someday: caller should pass in a flag saying whether it
       is binary or not.  I haven't carefully looked into whether
       CVS/Template files should use local text file conventions or
       not.  */
    fp = fopen (filename, "wb");
    if (fp == NULL)
    error (1, errno, "cannot write %s", fullname);
    nread = size;
    nwrite = 0;
    pread = buf;
    pwrite = buf;
    while (nread > 0 || nwrite > 0)
    {
    size_t n;

    if (nread > 0)
    {
        n = try_read_from_server (pread, nread);
        nread -= n;
        pread += n;
        nwrite += n;
    }

    if (nwrite > 0)
    {
        n = fwrite (pwrite, 1, nwrite, fp);
        if (ferror (fp))
        error (1, errno, "cannot write %s", fullname);
        nwrite -= n;
        pwrite += n;
    }
    }
    free (buf);
    if (fclose (fp) < 0)
    error (1, errno, "cannot close %s", fullname);
}

/*
 * The Checksum response gives the checksum for the file transferred
 * over by the next Updated, Merged or Patch response.  We just store
 * it here, and then check it in update_entries.
 */

static int stored_checksum_valid;
static unsigned char stored_checksum[16];

static void
handle_checksum (args, len)
    char *args;
    int len;
{
    char *s;
    char buf[3];
    int i;

    if (stored_checksum_valid)
        error (1, 0, "Checksum received before last one was used");

    s = args;
    buf[2] = '\0';
    for (i = 0; i < 16; i++)
    {
        char *bufend;

    buf[0] = *s++;
    buf[1] = *s++;
    stored_checksum[i] = (char) strtol (buf, &bufend, 16);
    if (bufend != buf + 2)
        break;
    }

    if (i < 16 || *s != '\0')
        error (1, 0, "Invalid Checksum response: `%s'", args);

    stored_checksum_valid = 1;
}

static int stored_mode_valid;
static char *stored_mode;

static void handle_mode PROTO ((char *, int));

static void
handle_mode (args, len)
    char *args;
    int len;
{
    if (stored_mode_valid)
    error (1, 0, "protocol error: duplicate Mode");
    if (stored_mode != NULL)
    free (stored_mode);
    stored_mode = xstrdup (args);
    stored_mode_valid = 1;
}

/*
 * If we receive a patch, but the patch program fails to apply it, we
 * want to request the original file.  We keep a list of files whose
 * patches have failed.
 */

char **failed_patches;
int failed_patches_count;

struct update_entries_data
{
    enum {
      /*
       * We are just getting an Entries line; the local file is
       * correct.
       */
      UPDATE_ENTRIES_CHECKIN,
      /* We are getting the file contents as well.  */
      UPDATE_ENTRIES_UPDATE,
      /*
       * We are getting a patch against the existing local file, not
       * an entire new file.
       */
      UPDATE_ENTRIES_PATCH
    } contents;

    /*
     * String to put in the timestamp field or NULL to use the timestamp
     * of the file.
     */
    char *timestamp;
};

/* Update the Entries line for this file.  */
static void
update_entries (data_arg, ent_list, short_pathname, filename)
    char *data_arg;
    List *ent_list;
    char *short_pathname;
    char *filename;
{
    char *entries_line;
    struct update_entries_data *data = (struct update_entries_data *)data_arg;

    char *cp;
    char *user;
    char *vn;
    /* Timestamp field.  Always empty according to the protocol.  */
    char *ts;
    char *options;
    char *tag;
    char *date;
    char *tag_or_date;
    char *scratch_entries;
    int bin;

    read_line (&entries_line, 0);

    /*
     * Parse the entries line.
     */
    if (strcmp (command_name, "export") != 0)
    {
    scratch_entries = xstrdup (entries_line);

    if (scratch_entries[0] != '/')
        error (1, 0, "bad entries line `%s' from server", entries_line);
    user = scratch_entries + 1;
    if ((cp = strchr (user, '/')) == NULL)
        error (1, 0, "bad entries line `%s' from server", entries_line);
    *cp++ = '\0';
    vn = cp;
    if ((cp = strchr (vn, '/')) == NULL)
        error (1, 0, "bad entries line `%s' from server", entries_line);
    *cp++ = '\0';

    ts = cp;
    if ((cp = strchr (ts, '/')) == NULL)
        error (1, 0, "bad entries line `%s' from server", entries_line);
    *cp++ = '\0';
    options = cp;
    if ((cp = strchr (options, '/')) == NULL)
        error (1, 0, "bad entries line `%s' from server", entries_line);
    *cp++ = '\0';
    tag_or_date = cp;

    /* If a slash ends the tag_or_date, ignore everything after it.  */
    cp = strchr (tag_or_date, '/');
    if (cp != NULL)
        *cp = '\0';
    tag = (char *) NULL;
    date = (char *) NULL;
    if (*tag_or_date == 'T')
        tag = tag_or_date + 1;
    else if (*tag_or_date == 'D')
        date = tag_or_date + 1;
    }
    else
    /* For cvs export, assume it is a text file.  FIXME: This is
       broken behavior--we should be having the server tell us
       whether it is text or binary and dealing accordingly.  I
       think maybe we can parse the entries line, get the options,
       and then ignore the entries line otherwise, but I haven't
       checked to see whether the server sends the entries line
       correctly in this case.  */
    options = NULL;

    if (data->contents == UPDATE_ENTRIES_UPDATE
    || data->contents == UPDATE_ENTRIES_PATCH)
    {
    char *size_string;
    char *mode_string;
    int size;
    int fd;
    char *buf;
    char *temp_filename;
    int use_gzip, gzip_status;
    pid_t gzip_pid = 0;

    read_line (&mode_string, 0);

    read_line (&size_string, 0);
    if (size_string[0] == 'z')
    {
        use_gzip = 1;
        size = atoi (size_string+1);
    }
    else
    {
        use_gzip = 0;
        size = atoi (size_string);
    }
    free (size_string);

    temp_filename = xmalloc (strlen (filename) + 80);
#ifdef USE_VMS_FILENAMES
        /* A VMS rename of "blah.dat" to "foo" to implies a
           destination of "foo.dat" which is unfortinate for CVS */
       sprintf (temp_filename, "%s_new_", filename);
#else
#ifdef _POSIX_NO_TRUNC
    sprintf (temp_filename, ".new.%.9s", filename);
#else /* _POSIX_NO_TRUNC */
    sprintf (temp_filename, ".new.%s", filename);
#endif /* _POSIX_NO_TRUNC */
#endif /* USE_VMS_FILENAMES */
    buf = xmalloc (size);

        /* Some systems, like OS/2 and Windows NT, end lines with CRLF
           instead of just LF.  Format translation is done in the C
           library I/O funtions.  Here we tell them whether or not to
           convert -- if this file is marked "binary" with the RCS -kb
           flag, then we don't want to convert, else we do (because
           CVS assumes text files by default). */

    if (options)
        bin = !(strcmp (options, "-kb"));
    else
        bin = 0;

        fd = open (temp_filename,
                   O_WRONLY | O_CREAT | O_TRUNC | (bin ? OPEN_BINARY : 0),
                   0777);

    if (fd < 0)
        error (1, errno, "writing %s", short_pathname);

    if (use_gzip)
        fd = filter_through_gunzip (fd, 0, &gzip_pid);

    if (size > 0)
    {
          read_from_server (buf, size);

          if (write (fd, buf, size) != size)
            error (1, errno, "writing %s", short_pathname);
    }

    if (close (fd) < 0)
        error (1, errno, "writing %s", short_pathname);
    if (gzip_pid > 0)
    {
        if (waitpid (gzip_pid, &gzip_status, 0) == -1)
        error (1, errno, "waiting for gzip process %ld",
               (long) gzip_pid);
        else if (gzip_status != 0)
        error (1, 0, "gzip process exited %d", gzip_status);
    }

    gzip_pid = -1;

    /* Since gunzip writes files without converting LF to CRLF
       (a reasonable behavior), we now have a patch file in LF
       format.  Leave the file as is if we're just going to feed
       it to patch; patch can handle it.  However, if it's the
       final source file, convert it.  */

    if (data->contents == UPDATE_ENTRIES_UPDATE)
    {
#ifdef LINES_CRLF_TERMINATED

            /* `bin' is non-zero iff `options' contains "-kb", meaning
                treat this file as binary. */

        if (use_gzip && (! bin))
        {
            convert_file (temp_filename, O_RDONLY | OPEN_BINARY,
                      filename, O_WRONLY | O_CREAT | O_TRUNC);
            if (unlink (temp_filename) < 0)
                error (0, errno, "warning: couldn't delete %s",
                           temp_filename);
        }
        else
        rename_file (temp_filename, filename);

#else /* ! LINES_CRLF_TERMINATED */
        rename_file (temp_filename, filename);
#endif /* LINES_CRLF_TERMINATED */
    }
    else
    {
        int retcode;
        char backup[PATH_MAX];
        struct stat s;

        (void) sprintf (backup, "%s~", filename);
        (void) unlink_file (backup);
        if (!isfile (filename))
            error (1, 0, "patch original file %s does not exist",
               short_pathname);
        if (stat (temp_filename, &s) < 0)
            error (1, 1, "can't stat patch file %s", temp_filename);
        if (s.st_size == 0)
            retcode = 0;
        else
        {
            run_setup ("%s -f -s -b ~ %s %s", PATCH_PROGRAM,
               filename, temp_filename);
        retcode = run_exec (DEVNULL, RUN_TTY, RUN_TTY, RUN_NORMAL);
        }
        /* FIXME: should we really be silently ignoring errors?  */
        (void) unlink_file (temp_filename);
        if (retcode == 0)
        {
        /* FIXME: should we really be silently ignoring errors?  */
        (void) unlink_file (backup);
        }
        else
        {
            int old_errno = errno;
        char *path_tmp;

            if (isfile (backup))
            rename_file (backup, filename);

        /* Get rid of the patch reject file.  */
        path_tmp = xmalloc (strlen (filename) + 10);
        strcpy (path_tmp, filename);
        strcat (path_tmp, ".rej");
        /* FIXME: should we really be silently ignoring errors?  */
        (void) unlink_file (path_tmp);
        free (path_tmp);

        /* Save this file to retrieve later.  */
        failed_patches =
            (char **) xrealloc ((char *) failed_patches,
                    ((failed_patches_count + 1)
                     * sizeof (char *)));
        failed_patches[failed_patches_count] =
            xstrdup (short_pathname);
        ++failed_patches_count;

        error (retcode == -1 ? 1 : 0, retcode == -1 ? old_errno : 0,
               "could not patch %s%s", filename,
               retcode == -1 ? "" : "; will refetch");

        stored_checksum_valid = 0;

        return;
        }
    }
    free (temp_filename);

    if (stored_checksum_valid)
    {
        FILE *e;
        struct MD5Context context;
        unsigned char buf[8192];
        unsigned len;
        unsigned char checksum[16];

        /*
         * Compute the MD5 checksum.  This will normally only be
         * used when receiving a patch, so we always compute it
         * here on the final file, rather than on the received
         * data.
         *
         * Note that if the file is a text file, we should read it
         * here using text mode, so its lines will be terminated the same
         * way they were transmitted.
         */
        e = fopen (filename, "r");
        if (e == NULL)
            error (1, errno, "could not open %s", short_pathname);

        MD5Init (&context);
        while ((len = fread (buf, 1, sizeof buf, e)) != 0)
        MD5Update (&context, buf, len);
        if (ferror (e))
        error (1, errno, "could not read %s", short_pathname);
        MD5Final (checksum, &context);

        fclose (e);

        stored_checksum_valid = 0;

        if (memcmp (checksum, stored_checksum, 16) != 0)
        {
            if (data->contents != UPDATE_ENTRIES_PATCH)
            error (1, 0, "checksum failure on %s",
               short_pathname);

        error (0, 0,
               "checksum failure after patch to %s; will refetch",
               short_pathname);

        /* Save this file to retrieve later.  */
        failed_patches =
            (char **) xrealloc ((char *) failed_patches,
                    ((failed_patches_count + 1)
                     * sizeof (char *)));
        failed_patches[failed_patches_count] =
            xstrdup (short_pathname);
        ++failed_patches_count;

        return;
        }
    }

        {
        /* FIXME: we should be respecting the umask.  */
        int status = change_mode (filename, mode_string);
        if (status != 0)
        error (0, status, "cannot change mode of %s", short_pathname);
    }

    free (mode_string);
    free (buf);
    }

    if (stored_mode_valid)
    change_mode (filename, stored_mode);
    stored_mode_valid = 0;

    /*
     * Process the entries line.  Do this after we've written the file,
     * since we need the timestamp.
     */
    if (strcmp (command_name, "export") != 0)
    {
    char *local_timestamp;
    char *file_timestamp;

    local_timestamp = data->timestamp;
    if (local_timestamp == NULL || ts[0] == '+')
        file_timestamp = time_stamp (filename);
    else
        file_timestamp = NULL;

    /*
     * These special version numbers signify that it is not up to
     * date.  Create a dummy timestamp which will never compare
     * equal to the timestamp of the file.
     */
    if (vn[0] == '\0' || vn[0] == '0' || vn[0] == '-')
        local_timestamp = "dummy timestamp";
    else if (local_timestamp == NULL)
    {
        local_timestamp = file_timestamp;
        mark_up_to_date (filename);
    }

    Register (ent_list, filename, vn, local_timestamp,
          options, tag, date, ts[0] == '+' ? file_timestamp : NULL);

    if (file_timestamp)
        free (file_timestamp);

    free (scratch_entries);
    }
    free (entries_line);
}

static void
handle_checked_in (args, len)
    char *args;
    int len;
{
    struct update_entries_data dat;
    dat.contents = UPDATE_ENTRIES_CHECKIN;
    dat.timestamp = NULL;
    call_in_directory (args, update_entries, (char *)&dat);
}

static void
handle_new_entry (args, len)
    char *args;
    int len;
{
    struct update_entries_data dat;
    dat.contents = UPDATE_ENTRIES_CHECKIN;
    dat.timestamp = "dummy timestamp from new-entry";
    call_in_directory (args, update_entries, (char *)&dat);
}

static void
handle_updated (args, len)
    char *args;
    int len;
{
    struct update_entries_data dat;
    dat.contents = UPDATE_ENTRIES_UPDATE;
    dat.timestamp = NULL;
    call_in_directory (args, update_entries, (char *)&dat);
}

static void
handle_merged (args, len)
    char *args;
    int len;
{
    struct update_entries_data dat;
    dat.contents = UPDATE_ENTRIES_UPDATE;
    dat.timestamp = "Result of merge";
    call_in_directory (args, update_entries, (char *)&dat);
}

static void
handle_patched (args, len)
     char *args;
     int len;
{
    struct update_entries_data dat;
    dat.contents = UPDATE_ENTRIES_PATCH;
    dat.timestamp = NULL;
    call_in_directory (args, update_entries, (char *)&dat);
}

static void
remove_entry (data, ent_list, short_pathname, filename)
    char *data;
    List *ent_list;
    char *short_pathname;
    char *filename;
{
    Scratch_Entry (ent_list, filename);
}

static void
handle_remove_entry (args, len)
    char *args;
    int len;
{
    call_in_directory (args, remove_entry, (char *)NULL);
}

static void
remove_entry_and_file (data, ent_list, short_pathname, filename)
    char *data;
    List *ent_list;
    char *short_pathname;
    char *filename;
{
    Scratch_Entry (ent_list, filename);
    if (unlink_file (filename) < 0)
    error (0, errno, "unable to remove %s", short_pathname);
}

static void
handle_removed (args, len)
    char *args;
    int len;
{
    call_in_directory (args, remove_entry_and_file, (char *)NULL);
}

/* Is this the top level (directory containing CVSROOT)?  */
static int
is_cvsroot_level (pathname)
    char *pathname;
{
    char *short_pathname;

    if (strcmp (toplevel_repos, server_cvsroot) != 0)
    return 0;

    if (!use_directory)
    {
    if (strncmp (pathname, server_cvsroot, strlen (server_cvsroot)) != 0)
        error (1, 0,
           "server bug: pathname `%s' doesn't specify file in `%s'",
           pathname, server_cvsroot);
    short_pathname = pathname + strlen (server_cvsroot) + 1;
    if (short_pathname[-1] != '/')
        error (1, 0,
           "server bug: pathname `%s' doesn't specify file in `%s'",
           pathname, server_cvsroot);
    return strchr (short_pathname, '/') == NULL;
    }
    else
    {
    return strchr (pathname, '/') == NULL;
    }
}

static void
set_static (data, ent_list, short_pathname, filename)
    char *data;
    List *ent_list;
    char *short_pathname;
    char *filename;
{
    FILE *fp;
    fp = open_file (CVSADM_ENTSTAT, "w+");
    if (fclose (fp) == EOF)
        error (1, errno, "cannot close %s", CVSADM_ENTSTAT);
}

static void
handle_set_static_directory (args, len)
    char *args;
    int len;
{
    if (strcmp (command_name, "export") == 0)
    {
    /* Swallow the repository.  */
    read_line (NULL, 0);
    return;
    }
    call_in_directory (args, set_static, (char *)NULL);
}

static void
clear_static (data, ent_list, short_pathname, filename)
    char *data;
    List *ent_list;
    char *short_pathname;
    char *filename;
{
    if (unlink_file (CVSADM_ENTSTAT) < 0 && ! existence_error (errno))
        error (1, errno, "cannot remove file %s", CVSADM_ENTSTAT);
}

static void
handle_clear_static_directory (pathname, len)
    char *pathname;
    int len;
{
    if (strcmp (command_name, "export") == 0)
    {
    /* Swallow the repository.  */
    read_line (NULL, 0);
    return;
    }

    if (is_cvsroot_level (pathname))
    {
        /*
     * Top level (directory containing CVSROOT).  This seems to normally
     * lack a CVS directory, so don't try to create files in it.
     */
    return;
    }
    call_in_directory (pathname, clear_static, (char *)NULL);
}

static void
set_sticky (data, ent_list, short_pathname, filename)
    char *data;
    List *ent_list;
    char *short_pathname;
    char *filename;
{
    char *tagspec;
    FILE *f;

    read_line (&tagspec, 0);
    f = open_file (CVSADM_TAG, "w+");
    if (fprintf (f, "%s\n", tagspec) < 0)
    error (1, errno, "writing %s", CVSADM_TAG);
    if (fclose (f) == EOF)
    error (1, errno, "closing %s", CVSADM_TAG);
    free (tagspec);
}

static void
handle_set_sticky (pathname, len)
    char *pathname;
    int len;
{
    if (strcmp (command_name, "export") == 0)
    {
    /* Swallow the repository.  */
    read_line (NULL, 0);
        /* Swallow the tag line.  */
    (void) read_line (NULL, 0);
    return;
    }
    if (is_cvsroot_level (pathname))
    {
        /*
     * Top level (directory containing CVSROOT).  This seems to normally
     * lack a CVS directory, so don't try to create files in it.
     */

    /* Swallow the repository.  */
    read_line (NULL, 0);
        /* Swallow the tag line.  */
    (void) read_line (NULL, 0);
    return;
    }

    call_in_directory (pathname, set_sticky, (char *)NULL);
}

static void
clear_sticky (data, ent_list, short_pathname, filename)
    char *data;
    List *ent_list;
    char *short_pathname;
    char *filename;
{
    if (unlink_file (CVSADM_TAG) < 0 && ! existence_error (errno))
    error (1, errno, "cannot remove %s", CVSADM_TAG);
}

static void
handle_clear_sticky (pathname, len)
    char *pathname;
    int len;
{
    if (strcmp (command_name, "export") == 0)
    {
    /* Swallow the repository.  */
    read_line (NULL, 0);
    return;
    }

    if (is_cvsroot_level (pathname))
    {
        /*
     * Top level (directory containing CVSROOT).  This seems to normally
     * lack a CVS directory, so don't try to create files in it.
     */
    return;
    }

    call_in_directory (pathname, clear_sticky, (char *)NULL);
}


static void template PROTO ((char *, List *, char *, char *));

static void
template (data, ent_list, short_pathname, filename)
    char *data;
    List *ent_list;
    char *short_pathname;
    char *filename;
{
    /* FIXME: should be computing second argument from CVSADM_TEMPLATE
       and short_pathname.  */
    read_counted_file (CVSADM_TEMPLATE, "<CVS/Template file>");
}

static void handle_template PROTO ((char *, int));

static void
handle_template (pathname, len)
    char *pathname;
    int len;
{
    call_in_directory (pathname, template, NULL);
}


struct save_prog {
    char *name;
    char *dir;
    struct save_prog *next;
};

static struct save_prog *checkin_progs;
static struct save_prog *update_progs;

/*
 * Unlike some responses this doesn't include the repository.  So we can't
 * just call call_in_directory and have the right thing happen; we save up
 * the requests and do them at the end.
 */
static void
handle_set_checkin_prog (args, len)
    char *args;
    int len;
{
    char *prog;
    struct save_prog *p;
    read_line (&prog, 0);
    p = (struct save_prog *) xmalloc (sizeof (struct save_prog));
    p->next = checkin_progs;
    p->dir = xstrdup (args);
    p->name = prog;
    checkin_progs = p;
}

static void
handle_set_update_prog (args, len)
    char *args;
    int len;
{
    char *prog;
    struct save_prog *p;
    read_line (&prog, 0);
    p = (struct save_prog *) xmalloc (sizeof (struct save_prog));
    p->next = update_progs;
    p->dir = xstrdup (args);
    p->name = prog;
    update_progs = p;
}

static void do_deferred_progs PROTO((void));

static void
do_deferred_progs ()
{
    struct save_prog *p;
    struct save_prog *q;

    char fname[PATH_MAX];
    FILE *f;
    if (toplevel_wd[0] != '\0')
      {
    if (chdir (toplevel_wd) < 0)
      error (1, errno, "could not chdir to %s", toplevel_wd);
      }
    for (p = checkin_progs; p != NULL; )
    {
    sprintf (fname, "%s/%s", p->dir, CVSADM_CIPROG);
    f = open_file (fname, "w");
    if (fprintf (f, "%s\n", p->name) < 0)
        error (1, errno, "writing %s", fname);
    if (fclose (f) == EOF)
        error (1, errno, "closing %s", fname);
    free (p->name);
    free (p->dir);
    q = p->next;
    free (p);
    p = q;
    }
    checkin_progs = NULL;
    for (p = update_progs; p != NULL; p = p->next)
    {
    sprintf (fname, "%s/%s", p->dir, CVSADM_UPROG);
    f = open_file (fname, "w");
    if (fprintf (f, "%s\n", p->name) < 0)
        error (1, errno, "writing %s", fname);
    if (fclose (f) == EOF)
        error (1, errno, "closing %s", fname);
    free (p->name);
    free (p->dir);
    free (p);
    }
    update_progs = NULL;
}

static int client_isemptydir PROTO((char *));

/*
 * Returns 1 if the argument directory exists and is completely empty,
 * other than the existence of the CVS directory entry.  Zero otherwise.
 */
static int
client_isemptydir (dir)
    char *dir;
{
    DIR *dirp;
    struct dirent *dp;

    if ((dirp = opendir (dir)) == NULL)
    {
    if (! existence_error (errno))
        error (0, errno, "cannot open directory %s for empty check", dir);
    return (0);
    }
    errno = 0;
    while ((dp = readdir (dirp)) != NULL)
    {
    if (strcmp (dp->d_name, ".") != 0 && strcmp (dp->d_name, "..") != 0 &&
        strcmp (dp->d_name, CVSADM) != 0)
    {
        (void) closedir (dirp);
        return (0);
    }
    }
    if (errno != 0)
    {
    error (0, errno, "cannot read directory %s", dir);
    (void) closedir (dirp);
    return (0);
    }
    (void) closedir (dirp);
    return (1);
}

struct save_dir {
    char *dir;
    struct save_dir *next;
};

struct save_dir *prune_candidates;

static void
add_prune_candidate (dir)
    char *dir;
{
    struct save_dir *p;

    if (dir[0] == '.' && dir[1] == '\0')
    return;
    p = (struct save_dir *) xmalloc (sizeof (struct save_dir));
    p->dir = xstrdup (dir);
    p->next = prune_candidates;
    prune_candidates = p;
}

static void process_prune_candidates PROTO((void));

static void
process_prune_candidates ()
{
    struct save_dir *p;
    struct save_dir *q;

    if (toplevel_wd[0] != '\0')
      {
    if (chdir (toplevel_wd) < 0)
      error (1, errno, "could not chdir to %s", toplevel_wd);
      }
    for (p = prune_candidates; p != NULL; )
    {
    if (client_isemptydir (p->dir))
    {
          unlink_file_dir (p->dir);
    }
    free (p->dir);
    q = p->next;
    free (p);
    p = q;
    }
}

/* Send a Repository line.  */

static char *last_repos;
static char *last_update_dir;

static void send_repository PROTO((char *, char *, char *));

static void
send_repository (dir, repos, update_dir)
    char *dir;
    char *repos;
    char *update_dir;
{
    char *adm_name;

    /* FIXME: this is probably not the best place to check; I wish I
     * knew where in here's callers to really trap this bug.  To
     * reproduce the bug, just do this:
     *
     *       mkdir junk
     *       cd junk
     *       cvs -d some_repos update foo
     *
     * Poof, CVS seg faults and dies!  It's because it's trying to
     * send a NULL string to the server but dies in send_to_server.
     * That string was supposed to be the repository, but it doesn't
     * get set because there's no CVSADM dir, and somehow it's not
     * getting set from the -d argument either... ?
     */
    if (repos == NULL)
    {
        /* Lame error.  I want a real fix but can't stay up to track
           this down right now. */
        error (1, 0, "no repository");
    }

    if (update_dir == NULL || update_dir[0] == '\0')
    update_dir = ".";

    if (last_repos != NULL
    && strcmp (repos, last_repos) == 0
    && last_update_dir != NULL
    && strcmp (update_dir, last_update_dir) == 0)
    /* We've already sent it.  */
    return;

    if (client_prune_dirs)
    add_prune_candidate (update_dir);

    /* 80 is large enough for any of CVSADM_*.  */
    adm_name = xmalloc (strlen (dir) + 80);

    if (use_directory == -1)
    use_directory = supported_request ("Directory");

    if (use_directory)
    {
    send_to_server ("Directory ", 0);
    send_to_server (update_dir, 0);
    send_to_server ("\012", 1);
    send_to_server (repos, 0);
    send_to_server ("\012", 1);
    }
    else
    {
    send_to_server ("Repository ", 0);
    send_to_server (repos, 0);
    send_to_server ("\012", 1);
    }
    if (supported_request ("Static-directory"))
    {
    adm_name[0] = '\0';
    if (dir[0] != '\0')
    {
        strcat (adm_name, dir);
        strcat (adm_name, "/");
    }
    strcat (adm_name, CVSADM_ENTSTAT);
    if (isreadable (adm_name))
    {
        send_to_server ("Static-directory\012", 0);
    }
    }
    if (supported_request ("Sticky"))
    {
    FILE *f;
    if (dir[0] == '\0')
        strcpy (adm_name, CVSADM_TAG);
    else
        sprintf (adm_name, "%s/%s", dir, CVSADM_TAG);

    f = fopen (adm_name, "r");
    if (f == NULL)
    {
        if (! existence_error (errno))
        error (1, errno, "reading %s", adm_name);
    }
    else
    {
        char line[80];
        char *nl;
        send_to_server ("Sticky ", 0);
        while (fgets (line, sizeof (line), f) != NULL)
        {
        send_to_server (line, 0);
        nl = strchr (line, '\n');
        if (nl != NULL)
            break;
        }
        if (nl == NULL)
                send_to_server ("\012", 1);
        if (fclose (f) == EOF)
        error (0, errno, "closing %s", adm_name);
    }
    }
    if (supported_request ("Checkin-prog"))
    {
    FILE *f;
    if (dir[0] == '\0')
        strcpy (adm_name, CVSADM_CIPROG);
    else
        sprintf (adm_name, "%s/%s", dir, CVSADM_CIPROG);

    f = fopen (adm_name, "r");
    if (f == NULL)
    {
        if (! existence_error (errno))
        error (1, errno, "reading %s", adm_name);
    }
    else
    {
        char line[80];
        char *nl;

        send_to_server ("Checkin-prog ", 0);

        while (fgets (line, sizeof (line), f) != NULL)
        {
        send_to_server (line, 0);

        nl = strchr (line, '\n');
        if (nl != NULL)
            break;
        }
        if (nl == NULL)
        send_to_server ("\012", 1);
        if (fclose (f) == EOF)
        error (0, errno, "closing %s", adm_name);
    }
    }
    if (supported_request ("Update-prog"))
    {
    FILE *f;
    if (dir[0] == '\0')
        strcpy (adm_name, CVSADM_UPROG);
    else
        sprintf (adm_name, "%s/%s", dir, CVSADM_UPROG);

    f = fopen (adm_name, "r");
    if (f == NULL)
    {
        if (! existence_error (errno))
        error (1, errno, "reading %s", adm_name);
    }
    else
    {
        char line[80];
        char *nl;

        send_to_server ("Update-prog ", 0);

        while (fgets (line, sizeof (line), f) != NULL)
        {
        send_to_server (line, 0);

        nl = strchr (line, '\n');
        if (nl != NULL)
            break;
        }
        if (nl == NULL)
        send_to_server ("\012", 1);
        if (fclose (f) == EOF)
        error (0, errno, "closing %s", adm_name);
    }
    }
    free (adm_name);
    if (last_repos != NULL)
    free (last_repos);
    if (last_update_dir != NULL)
    free (last_update_dir);
    last_repos = xstrdup (repos);
    last_update_dir = xstrdup (update_dir);
}

/* Send a Repository line and set toplevel_repos.  */
static void send_a_repository PROTO((char *, char *, char *));

static void
send_a_repository (dir, repository, update_dir)
    char *dir;
    char *repository;
    char *update_dir;
{
    if (toplevel_repos == NULL && repository != NULL)
    {
    if (update_dir[0] == '\0'
        || (update_dir[0] == '.' && update_dir[1] == '\0'))
        toplevel_repos = xstrdup (repository);
    else
    {
        /*
         * Get the repository from a CVS/Repository file if update_dir
         * is absolute.  This is not correct in general, because
         * the CVS/Repository file might not be the top-level one.
         * This is for cases like "cvs update /foo/bar" (I'm not
         * sure it matters what toplevel_repos we get, but it does
         * matter that we don't hit the "internal error" code below).
         */
        if (update_dir[0] == '/')
        toplevel_repos = Name_Repository (update_dir, update_dir);
        else
        {
        /*
         * Guess the repository of that directory by looking at a
         * subdirectory and removing as many pathname components
         * as are in update_dir.  I think that will always (or at
         * least almost always) be 1.
         *
         * So this deals with directories which have been
         * renamed, though it doesn't necessarily deal with
         * directories which have been put inside other
         * directories (and cvs invoked on the containing
         * directory).  I'm not sure the latter case needs to
         * work.
         */
        /*
         * This gets toplevel_repos wrong for "cvs update ../foo"
         * but I'm not sure toplevel_repos matters in that case.
         */
        int slashes_in_update_dir;
        int slashes_skipped;
        char *p;

        slashes_in_update_dir = 0;
        for (p = update_dir; *p != '\0'; ++p)
            if (*p == '/')
            ++slashes_in_update_dir;

        slashes_skipped = 0;
        p = repository + strlen (repository);
        while (1)
        {
            if (p == repository)
            error (1, 0,
                   "internal error: not enough slashes in %s",
                   repository);
            if (*p == '/')
            ++slashes_skipped;
            if (slashes_skipped < slashes_in_update_dir + 1)
            --p;
            else
            break;
        }
        toplevel_repos = xmalloc (p - repository + 1);
        /* Note that we don't copy the trailing '/'.  */
        strncpy (toplevel_repos, repository, p - repository);
        toplevel_repos[p - repository] = '\0';
        }
    }
    }

    send_repository (dir, repository, update_dir);
}

/* The "expanded" modules.  */
static int modules_count;
static int modules_allocated;
static char **modules_vector;

static void
handle_module_expansion (args, len)
    char *args;
    int len;
{
    if (modules_vector == NULL)
    {
    modules_allocated = 1; /* Small for testing */
    modules_vector = (char **) xmalloc
      (modules_allocated * sizeof (modules_vector[0]));
    }
    else if (modules_count >= modules_allocated)
    {
    modules_allocated *= 2;
    modules_vector = (char **) xrealloc
      ((char *) modules_vector,
       modules_allocated * sizeof (modules_vector[0]));
    }
    modules_vector[modules_count] = xmalloc (strlen (args) + 1);
    strcpy (modules_vector[modules_count], args);
    ++modules_count;
}

/* Original, not "expanded" modules.  */
static int module_argc;
static char **module_argv;

void
client_expand_modules (argc, argv, local)
    int argc;
    char **argv;
    int local;
{
    int errs;
    int i;

    module_argc = argc;
    module_argv = (char **) xmalloc ((argc + 1) * sizeof (module_argv[0]));
    for (i = 0; i < argc; ++i)
    module_argv[i] = xstrdup (argv[i]);
    module_argv[argc] = NULL;

    for (i = 0; i < argc; ++i)
    send_arg (argv[i]);
    send_a_repository ("", server_cvsroot, "");

    send_to_server ("expand-modules\012", 0);

    errs = get_server_responses ();
    if (last_repos != NULL)
        free (last_repos);
    last_repos = NULL;
    if (last_update_dir != NULL)
        free (last_update_dir);
    last_update_dir = NULL;
    if (errs)
    error (errs, 0, "cannot expand modules");
}

void
client_send_expansions (local)
     int local;
{
    int i;
    char *argv[1];

    /* Send the original module names.  The "expanded" module name might
       not be suitable as an argument to a co request (e.g. it might be
       the result of a -d argument in the modules file).  It might be
       cleaner if we genuinely expanded module names, all the way to a
       local directory and repository, but that isn't the way it works
       now.  */
    send_file_names (module_argc, module_argv, 0);

    for (i = 0; i < modules_count; ++i)
    {
    argv[0] = modules_vector[i];
    if (isfile (argv[0]))
        send_files (1, argv, local, 0);
    }
    send_a_repository ("", server_cvsroot, "");
}

void
client_nonexpanded_setup ()
{
    send_a_repository ("", server_cvsroot, "");
}

static void
handle_m (args, len)
    char *args;
    int len;
{
  fwrite (args, len, sizeof (*args), stdout);
  putc ('\n', stdout);
}

static void
handle_e (args, len)
    char *args;
    int len;
{
  fwrite (args, len, sizeof (*args), stderr);
  putc ('\n', stderr);
}

#endif /* CLIENT_SUPPORT */
#if defined(CLIENT_SUPPORT) || defined(SERVER_SUPPORT)

/* This table must be writeable if the server code is included.  */
struct response responses[] =
{
#ifdef CLIENT_SUPPORT
#define RSP_LINE(n, f, t, s) {n, f, t, s}
#else /* ! CLIENT_SUPPORT */
#define RSP_LINE(n, f, t, s) {n, s}
#endif /* CLIENT_SUPPORT */

    RSP_LINE("ok", handle_ok, response_type_ok, rs_essential),
    RSP_LINE("error", handle_error, response_type_error, rs_essential),
    RSP_LINE("Valid-requests", handle_valid_requests, response_type_normal,
       rs_essential),
    RSP_LINE("Checked-in", handle_checked_in, response_type_normal,
       rs_essential),
    RSP_LINE("New-entry", handle_new_entry, response_type_normal, rs_optional),
    RSP_LINE("Checksum", handle_checksum, response_type_normal, rs_optional),
    RSP_LINE("Copy-file", handle_copy_file, response_type_normal, rs_optional),
    RSP_LINE("Updated", handle_updated, response_type_normal, rs_essential),
    RSP_LINE("Merged", handle_merged, response_type_normal, rs_essential),
    RSP_LINE("Patched", handle_patched, response_type_normal, rs_optional),
    RSP_LINE("Mode", handle_mode, response_type_normal, rs_optional),
    RSP_LINE("Removed", handle_removed, response_type_normal, rs_essential),
    RSP_LINE("Remove-entry", handle_remove_entry, response_type_normal,
       rs_optional),
    RSP_LINE("Set-static-directory", handle_set_static_directory,
       response_type_normal,
       rs_optional),
    RSP_LINE("Clear-static-directory", handle_clear_static_directory,
       response_type_normal,
       rs_optional),
    RSP_LINE("Set-sticky", handle_set_sticky, response_type_normal,
       rs_optional),
    RSP_LINE("Clear-sticky", handle_clear_sticky, response_type_normal,
       rs_optional),
    RSP_LINE("Template", handle_template, response_type_normal,
       rs_optional),
    RSP_LINE("Set-checkin-prog", handle_set_checkin_prog, response_type_normal,
       rs_optional),
    RSP_LINE("Set-update-prog", handle_set_update_prog, response_type_normal,
       rs_optional),
    RSP_LINE("Notified", handle_notified, response_type_normal, rs_optional),
    RSP_LINE("Module-expansion", handle_module_expansion, response_type_normal,
       rs_optional),
    RSP_LINE("M", handle_m, response_type_normal, rs_essential),
    RSP_LINE("E", handle_e, response_type_normal, rs_essential),
    /* Possibly should be response_type_error.  */
    RSP_LINE(NULL, NULL, response_type_normal, rs_essential)

#undef RSP_LINE
};

#endif /* CLIENT_SUPPORT or SERVER_SUPPORT */
#ifdef CLIENT_SUPPORT

/*
 * If LEN is 0, then send_to_server() computes string's length itself.
 *
 * Therefore, pass the real length when transmitting data that might
 * contain 0's.
 */
void
send_to_server (str, len)
     char *str;
     size_t len;
{
  if (len == 0)
    len = strlen (str);

#ifdef NO_SOCKET_TO_FD
  if (use_socket_style)
    {
      int just_wrtn = 0;
      size_t wrtn = 0;

#ifdef VMS
      /* send() blocks under VMS */
      if (send (server_sock, str + wrtn, len - wrtn, 0) < 0)
        error (1, errno, "writing to server socket");
#else /* VMS */
      while (wrtn < len)
        {
          just_wrtn = send (server_sock, str + wrtn, len - wrtn, 0);

          if (just_wrtn == -1)
            error (1, errno, "writing to server socket");

          wrtn += just_wrtn;
          if (wrtn == len)
            break;
        }
#endif  /* VMS */
    }
  else
#endif /* NO_SOCKET_TO_FD */
    {
      size_t wrtn = 0;

      while (wrtn < len)
        {
          wrtn += fwrite (str + wrtn, 1, len - wrtn, to_server);

          if (wrtn == len)
            break;

          if (ferror (to_server))
            error (1, errno, "writing to server");
          if (feof (to_server))
            error (1, 0, "premature end-of-file on server");
        }
    }

  if (to_server_logfile)
    if (fwrite (str, 1, len, to_server_logfile) < len)
      error (0, errno, "writing to to-server logfile");
}

/* Read up to LEN bytes from the server.  Returns actual number of bytes
   read.  Gives a fatal error on EOF or error.  */
static size_t
try_read_from_server (buf, len)
    char *buf;
    size_t len;
{
    int nread;

#ifdef NO_SOCKET_TO_FD
    if (use_socket_style)
    {
    nread = recv (server_sock, buf, len, 0);
    if (nread == -1)
        error (1, errno, "reading from server");
    }
    else
#endif
    {
    nread = fread (buf, 1, len, from_server);
    if (ferror (from_server))
        error (1, errno, "reading from server");
    if (feof (from_server))
        error (1, 0,
           "end of file from server (consult above messages if any)");
    }

    /* Log, if that's what we're doing. */
    if (from_server_logfile != NULL && nread > 0)
    {
    size_t towrite = nread;
    if (fwrite (buf, 1, towrite, from_server_logfile) < towrite)
        error (0, errno, "writing to from-server logfile");
    }

    return nread;
}

/*
 * Read LEN bytes from the server or die trying.
 */
void
read_from_server (buf, len)
    char *buf;
    size_t len;
{
    size_t red = 0;
    while (red < len)
    {
    red += try_read_from_server (buf + red, len - red);
    if (red == len)
        break;
    }
}

/*
 * Get some server responses and process them.  Returns nonzero for
 * error, 0 for success.  */
int
get_server_responses ()
{
    struct response *rs;
    do
    {
    char *cmd;
    int len;

    len = read_line (&cmd, 0);
    for (rs = responses; rs->name != NULL; ++rs)
        if (strncmp (cmd, rs->name, strlen (rs->name)) == 0)
        {
        int cmdlen = strlen (rs->name);
        if (cmd[cmdlen] == '\0')
            ;
        else if (cmd[cmdlen] == ' ')
            ++cmdlen;
        else
            /*
             * The first len characters match, but it's a different
             * response.  e.g. the response is "oklahoma" but we
             * matched "ok".
             */
            continue;
        (*rs->func) (cmd + cmdlen, len - cmdlen);
        break;
        }
    if (rs->name == NULL)
        /* It's OK to print just to the first '\0'.  */
        error (0, 0,
           "warning: unrecognized response `%s' from cvs server",
           cmd);
    free (cmd);
    } while (rs->type == response_type_normal);
    return rs->type == response_type_error ? 1 : 0;
}

/* Get the responses and then close the connection.  */
int server_fd = -1;

/*
 * Flag var; we'll set it in start_server() and not one of its
 * callees, such as start_rsh_server().  This means that there might
 * be a small window between the starting of the server and the
 * setting of this var, but all the code in that window shouldn't care
 * because it's busy checking return values to see if the server got
 * started successfully anyway.
 */
int server_started = 0;

int
get_responses_and_close ()
{
    int errs = get_server_responses ();

    do_deferred_progs ();

    if (client_prune_dirs)
    process_prune_candidates ();

#ifdef NO_SOCKET_TO_FD
    if (use_socket_style)
      {
        if (shutdown (server_sock, 2) < 0)
          error (1, errno, "shutting down server socket");
      }
    else
#endif /* NO_SOCKET_TO_FD */
      {
#if defined(HAVE_KERBEROS) || defined(USE_DIRECT_TCP) || defined(AUTH_CLIENT_SUPPORT)
        if (server_fd != -1)
          {
            if (shutdown (server_fd, 1) < 0)
              error (1, errno, "shutting down connection to %s", server_host);
            /*
             * This test will always be true because we dup the descriptor
             */
            if (fileno (from_server) != fileno (to_server))
              {
                if (fclose (to_server) != 0)
                  error (1, errno,
                         "closing down connection to %s",
                         server_host);
              }
          }
        else
#endif /* HAVE_KERBEROS || USE_DIRECT_TCP || AUTH_CLIENT_SUPPORT */

#ifdef SHUTDOWN_SERVER
          SHUTDOWN_SERVER (fileno (to_server));
#else /* ! SHUTDOWN_SERVER */
        {

#ifdef START_RSH_WITH_POPEN_RW
          if (pclose (to_server) == EOF)
#else /* ! START_RSH_WITH_POPEN_RW */
            if (fclose (to_server) == EOF)
#endif /* START_RSH_WITH_POPEN_RW */
              {
                error (1, errno, "closing connection to %s", server_host);
              }
        }

        if (getc (from_server) != EOF)
          error (0, 0, "dying gasps from %s unexpected", server_host);
        else if (ferror (from_server))
          error (0, errno, "reading from %s", server_host);

        fclose (from_server);
#endif /* SHUTDOWN_SERVER */
      }

#if ! RSH_NOT_TRANSPARENT
    if (rsh_pid != -1
    && waitpid (rsh_pid, (int *) 0, 0) == -1)
    error (1, errno, "waiting for process %d", rsh_pid);
#endif /* ! RSH_NOT_TRANSPARENT */

    server_started = 0;

    return errs;
}

#ifndef RSH_NOT_TRANSPARENT
static void start_rsh_server PROTO((int *, int *));
#endif /* RSH_NOT_TRANSPARENT */

int
supported_request (name)
     char *name;
{
  struct request *rq;

  for (rq = requests; rq->name; rq++)
    if (!strcmp (rq->name, name))
      return rq->status == rq_supported;
  error (1, 0, "internal error: testing support for unknown option?");
  /* NOTREACHED */
  return 0;
}


#ifdef AUTH_CLIENT_SUPPORT
void
init_sockaddr (name, hostname, port)
    struct sockaddr_in *name;
    const char *hostname;
    unsigned short int port;
{
    struct hostent *hostinfo;

    memset (name, 0, sizeof (*name));
    name->sin_family = AF_INET;
    name->sin_port = htons (port);
    hostinfo = gethostbyname (hostname);
    if (hostinfo == NULL)
    {
    fprintf (stderr, "Unknown host %s.\n", hostname);
    exit (EXIT_FAILURE);
    }
    name->sin_addr = *(struct in_addr *) hostinfo->h_addr;
}


int
auth_server_port_number ()
{
  return CVS_AUTH_PORT;
}


/*
 * Connect to the authenticating server.
 *
 * If VERIFY_ONLY is non-zero, then just verify that the password is
 * correct and then shutdown the connection.  In this case, the return
 * values is 1 if the password was correct, 0 if not.
 *
 * If VERIFY_ONLY is 0, then really connect to the server.  In this
 * case the return value is 1 on succees, but is probably ignored.  If
 * fail to connect, then die with error.
 */
int
connect_to_pserver (tofdp, fromfdp, verify_only)
     int *tofdp, *fromfdp;
     int verify_only;
{
    int sock;
#ifndef NO_SOCKET_TO_FD
    int tofd, fromfd;
#endif
    int port_number;
    struct sockaddr_in client_sai;

    /* Does nothing if already called before now. */
    parse_cvsroot ();

    sock = socket (AF_INET, SOCK_STREAM, 0);
    if (sock == -1)
    {
    fprintf (stderr, "socket() failed\n");
    exit (EXIT_FAILURE);
    }
    port_number = auth_server_port_number ();
    init_sockaddr (&client_sai, server_host, port_number);
    if (connect (sock, (struct sockaddr *) &client_sai, sizeof (client_sai))
    < 0)
    error (1, errno, "connect to %s:%d failed", server_host,
           CVS_AUTH_PORT);

    /* Run the authorization mini-protocol before anything else. */
    {
    int i;
    char ch, read_buf[PATH_MAX];
    char *begin      = NULL;
    char *repository = server_cvsroot;
    char *username   = server_user;
    char *password   = NULL;
    char *end        = NULL;

    if (verify_only)
    {
        begin = "BEGIN VERIFICATION REQUEST\n";
        end   = "END VERIFICATION REQUEST\n";
    }
    else
    {
        begin = "BEGIN AUTH REQUEST\n";
        end   = "END AUTH REQUEST\n";
    }

    /* Get the password, probably from ~/.cvspass. */
    password = get_cvs_password (server_user, server_host, server_cvsroot);

    /* Announce that we're starting the authorization protocol. */
    send (sock, begin, strlen (begin), 0);

    /* Send the data the server needs. */
    send (sock, repository, strlen (repository), 0);
    send (sock, "\n", 1, 0);
    send (sock, username, strlen (username), 0);
    send (sock, "\n", 1, 0);
    send (sock, password, strlen (password), 0);
    send (sock, "\n", 1, 0);

    /* Announce that we're ending the authorization protocol. */
    send (sock, end, strlen (end), 0);

    /* Paranoia. */
    memset (password, 0, strlen (password));

    /* Get ACK or NACK from the server.
     *
     * We could avoid this careful read-char loop by having the ACK
     * and NACK cookies be of the same length, so we'd simply read
     * that length and see what we got.  But then there'd be Yet
     * Another Protocol Requirement floating around, and someday
     * someone would make a change that breaks it and spend a hellish
     * day tracking it down.  Therefore, we use "\n" to mark off the
     * end of both ACK and NACK, and we loop, reading until "\n".
     */
    ch = 0;
    memset (read_buf, 0, PATH_MAX);
    for (i = 0; (i < (PATH_MAX - 1)) && (ch != '\n'); i++)
    {
        if (recv (sock, &ch, 1, 0) < 0)
                error (1, errno, "recv() from server %s", server_host);

            read_buf[i] = ch;
    }

    if (strcmp (read_buf, "I HATE YOU\n") == 0)
    {
        /* Authorization not granted. */
        if (shutdown (sock, 2) < 0)
        {
        error (0, 0,
               "authorization failed: server %s rejected access",
               server_host);
        error (1, errno,
               "shutdown() failed (server %s)", server_host);
        }

        if (verify_only)
        return 0;
        else
        error (1, 0,
               "authorization failed: server %s rejected access",
               server_host);
    }
    else if (strcmp (read_buf, "I LOVE YOU\n") != 0)
    {
        /* Unrecognized response from server. */
        if (shutdown (sock, 2) < 0)
        {
        error (0, 0,
               "unrecognized auth response from %s: %s",
               server_host, read_buf);
        error (1, errno, "shutdown() failed, server %s", server_host);
        }
        error (1, 0,
           "unrecognized auth response from %s: %s",
           server_host, read_buf);
    }
    }

    if (verify_only)
    {
    if (shutdown (sock, 2) < 0)
        error (0, errno, "shutdown() failed, server %s", server_host);
    return 1;
    }
    else
    {
#ifdef NO_SOCKET_TO_FD
    use_socket_style = 1;
    server_sock = sock;
    /* Try to break mistaken callers: */
    *tofdp = 0;
    *fromfdp = 0;
#else /* ! NO_SOCKET_TO_FD */
    server_fd = sock;
    close_on_exec (server_fd);
    tofd = fromfd = sock;
    /* Hand them back to the caller. */
    *tofdp   = tofd;
    *fromfdp = fromfd;
#endif /* NO_SOCKET_TO_FD */
    }

    return 1;
}
#endif /* AUTH_CLIENT_SUPPORT */


#if HAVE_KERBEROS || USE_DIRECT_TCP

/*
 * FIXME: this function has not been changed to deal with
 * NO_SOCKET_TO_FD (i.e., systems on which sockets cannot be converted
 * to file descriptors.  The first person to try building a kerberos
 * client on such a system (OS/2, Windows 95, and maybe others) will
 * have to make take care of this.
 */
void
start_tcp_server (tofdp, fromfdp)
     int *tofdp, *fromfdp;
{
  int tofd, fromfd;

  struct hostent *hp;
  char *hname;
  const char *portenv;
  int port;
  struct sockaddr_in sin;
  int s;


#if HAVE_KERBEROS
  KTEXT_ST ticket;
  const char *realm;
#endif /* HAVE_KERBEROS */

  int status;

  /*
   * We look up the host to give a better error message if it
   * does not exist.  However, we then pass server_host to
   * krb_sendauth, rather than the canonical name, because
   * krb_sendauth is going to do its own canonicalization anyhow
   * and that lets us not worry about the static storage used by
   * gethostbyname.
   */
  hp = gethostbyname (server_host);
  if (hp == NULL)
    error (1, 0, "%s: unknown host", server_host);
  hname = xmalloc (strlen (hp->h_name) + 1);
  strcpy (hname, hp->h_name);

#if HAVE_KERBEROS
  realm = krb_realmofhost (hname);
#endif /* HAVE_KERBEROS */

  /* Get CVS_CLIENT_PORT or look up cvs/tcp with CVS_PORT as default */
  portenv = getenv ("CVS_CLIENT_PORT");
  if (portenv != NULL)
    {
      port = atoi (portenv);
      if (port <= 0)
        goto try_rsh_no_message;
      if (trace)
        fprintf(stderr, "Using TCP port %d to contact server.\n", port);
      port = htons (port);
    }
  else
    {
      struct servent *sp;

      sp = getservbyname ("cvs", "tcp");
      if (sp == NULL)
        port = htons (CVS_PORT);
      else
        port = sp->s_port;
    }

  s = socket (AF_INET, SOCK_STREAM, 0);
  if (s < 0)
    error (1, errno, "socket");

  memset (&sin, 0, sizeof sin);
  sin.sin_family = AF_INET;
  sin.sin_addr.s_addr = INADDR_ANY;
  sin.sin_port = 0;

  if (bind (s, (struct sockaddr *) &sin, sizeof sin) < 0)
    error (1, errno, "bind");

  memcpy (&sin.sin_addr, hp->h_addr, hp->h_length);
  sin.sin_port = port;

  tofd = -1;
  if (connect (s, (struct sockaddr *) &sin, sizeof sin) < 0)
    {
      error (0, errno, "connect");
      close (s);
    }
  else
    {
#ifdef HAVE_KERBEROS
      struct sockaddr_in laddr;
      int laddrlen;
      MSG_DAT msg_data;
      CREDENTIALS cred;
      Key_schedule sched;

      laddrlen = sizeof (laddr);
      if (getsockname (s, (struct sockaddr *) &laddr, &laddrlen) < 0)
        error (1, errno, "getsockname");

      /* We don't care about the checksum, and pass it as zero.  */
      status = krb_sendauth (KOPT_DO_MUTUAL, s, &ticket, "rcmd",
                             hname, realm, (unsigned long) 0, &msg_data,
                             &cred, sched, &laddr, &sin, "KCVSV1.0");
      if (status != KSUCCESS)
        {
          error (0, 0, "kerberos: %s", krb_get_err_text(status));
          close (s);
        }
      else
        {
#endif /* HAVE_KERBEROS */

          server_fd = s;
          close_on_exec (server_fd);
          tofd = fromfd = s;

#ifdef HAVE_KERBEROS
        }
#endif /* HAVE_KERBEROS */
    }

  if (tofd == -1)
    {
      /* FIXME: Falling back like this is slow and we should probably
     just make it a fatal error (so that people use the right
     environment variables or, when we get around to implementing
     the right ones, access methods).  */
      error (0, 0, "trying to start server using rsh");
    try_rsh_no_message:
      server_fd = -1;
#if ! RSH_NOT_TRANSPARENT
      start_rsh_server (&tofd, &fromfd);
#else /* RSH_NOT_TRANSPARENT */
#if defined (START_SERVER)
      START_SERVER (&tofd, &fromfd, getcaller (),
                    server_user, server_host, server_cvsroot);
#endif /* defined (START_SERVER) */
#endif /* ! RSH_NOT_TRANSPARENT */
    }
  free (hname);

  /* Give caller the values it wants. */
  *tofdp   = tofd;
  *fromfdp = fromfd;
}

#endif /* HAVE_KERBEROS || USE_DIRECT_TCP */

static int send_variable_proc PROTO ((Node *, void *));

static int
send_variable_proc (node, closure)
    Node *node;
    void *closure;
{
    send_to_server ("Set ", 0);
    send_to_server (node->key, 0);
    send_to_server ("=", 1);
    send_to_server (node->data, 0);
    send_to_server ("\012", 1);
    return 0;
}

/* Contact the server.  */
void
start_server ()
{
  int tofd, fromfd;
  char *log = getenv ("CVS_CLIENT_LOG");

  /* Note that generally speaking we do *not* fall back to a different
     way of connecting if the first one does not work.  This is slow
     (*really* slow on a 14.4kbps link); the clean way to have a CVS
     which supports several ways of connecting is with access methods.  */

  /* Init these to NULL.  They will be set later if logging is on. */
  from_server_logfile = (FILE *) NULL;
  to_server_logfile   = (FILE *) NULL;

#ifdef AUTH_CLIENT_SUPPORT
    if (use_authenticating_server)
      {
        /* Toss the return value.  It will die with error if anything
           goes wrong anyway. */
        connect_to_pserver (&tofd, &fromfd, 0);
      }
    else
#endif /* AUTH_CLIENT_SUPPORT */
      {
#if HAVE_KERBEROS || USE_DIRECT_TCP
        start_tcp_server (&tofd, &fromfd);
#else

#  if ! RSH_NOT_TRANSPARENT
        start_rsh_server (&tofd, &fromfd);
#  else

#    if defined(START_SERVER)
        START_SERVER (&tofd, &fromfd, getcaller (),
                      server_user, server_host, server_cvsroot);
#    endif
#  endif
#endif
      }

#if defined(VMS) && defined(NO_SOCKET_TO_FD)
    /* Avoid mixing sockets with stdio */
    use_socket_style = 1;
    server_sock = tofd;
#endif /* VMS && NO_SOCKET_TO_FD */

    /* "Hi, I'm Darlene and I'll be your server tonight..." */
    server_started = 1;

    /* Set up logfiles, if any. */
    if (log)
    {
    int len = strlen (log);
    char *buf = xmalloc (len + 5);
    char *p;

    strcpy (buf, log);
    p = buf + len;

    strcpy (p, ".in");
    to_server_logfile = open_file (buf, "w");
        if (to_server_logfile == NULL)
          error (0, errno, "opening to-server logfile %s", buf);

    strcpy (p, ".out");
    from_server_logfile = open_file (buf, "w");
        if (from_server_logfile == NULL)
          error (0, errno, "opening from-server logfile %s", buf);

    free (buf);
    }

#ifdef NO_SOCKET_TO_FD
    if (! use_socket_style)
#endif /* NO_SOCKET_TO_FD */
      {
        /* todo: some OS's don't need these calls... */
        close_on_exec (tofd);
        close_on_exec (fromfd);

    /* SCO 3 and AIX have a nasty bug in the I/O libraries which precludes
       fdopening the same file descriptor twice, so dup it if it is the
       same.  */
    if (tofd == fromfd)
    {
        fromfd = dup (tofd);
        if (fromfd < 0)
        error (1, errno, "cannot dup net connection");
    }

        /* These will use binary mode on systems which have it.  */
        to_server = fdopen (tofd, FOPEN_BINARY_WRITE);
        if (to_server == NULL)
          error (1, errno, "cannot fdopen %d for write", tofd);
        from_server = fdopen (fromfd, FOPEN_BINARY_READ);
        if (from_server == NULL)
          error (1, errno, "cannot fdopen %d for read", fromfd);
      }

    /* Clear static variables.  */
    if (toplevel_repos != NULL)
        free (toplevel_repos);
    toplevel_repos = NULL;
    if (last_dir_name != NULL)
        free (last_dir_name);
    last_dir_name = NULL;
    if (last_repos != NULL)
        free (last_repos);
    last_repos = NULL;
    if (last_update_dir != NULL)
        free (last_update_dir);
    last_update_dir = NULL;
    stored_checksum_valid = 0;
    stored_mode_valid = 0;

    if (strcmp (command_name, "init") != 0)
    {
    send_to_server ("Root ", 0);
    send_to_server (server_cvsroot, 0);
    send_to_server ("\012", 1);
    }

    {
    struct response *rs;

    send_to_server ("Valid-responses", 0);

    for (rs = responses; rs->name != NULL; ++rs)
    {
        send_to_server (" ", 0);
        send_to_server (rs->name, 0);
    }
    send_to_server ("\012", 1);
    }
    send_to_server ("valid-requests\012", 0);

    if (get_server_responses ())
    exit (EXIT_FAILURE);

    /*
     * Now handle global options.
     *
     * -H, -f, -d, -e should be handled OK locally.
     *
     * -b we ignore (treating it as a server installation issue).
     * FIXME: should be an error message.
     *
     * -v we print local version info; FIXME: Add a protocol request to get
     * the version from the server so we can print that too.
     *
     * -l -t -r -w -q -n and -Q need to go to the server.
     */

    {
    int have_global = supported_request ("Global_option");

    if (noexec)
    {
        if (have_global)
        {
        send_to_server ("Global_option -n\012", 0);
        }
        else
        error (1, 0,
               "This server does not support the global -n option.");
    }
    if (quiet)
    {
        if (have_global)
        {
        send_to_server ("Global_option -q\012", 0);
        }
        else
        error (1, 0,
               "This server does not support the global -q option.");
    }
    if (really_quiet)
    {
        if (have_global)
        {
        send_to_server ("Global_option -Q\012", 0);
        }
        else
        error (1, 0,
               "This server does not support the global -Q option.");
    }
    if (!cvswrite)
    {
        if (have_global)
        {
        send_to_server ("Global_option -r\012", 0);
        }
        else
        error (1, 0,
               "This server does not support the global -r option.");
    }
    if (trace)
    {
        if (have_global)
        {
        send_to_server ("Global_option -t\012", 0);
        }
        else
        error (1, 0,
               "This server does not support the global -t option.");
    }
    if (logoff)
    {
        if (have_global)
        {
        send_to_server ("Global_option -l\012", 0);
        }
        else
        error (1, 0,
               "This server does not support the global -l option.");
    }
    }
    if (gzip_level)
    {
    if (supported_request ("gzip-file-contents"))
    {
            char gzip_level_buf[5];
        send_to_server ("gzip-file-contents ", 0);
            sprintf (gzip_level_buf, "%d", gzip_level);
        send_to_server (gzip_level_buf, 0);

        send_to_server ("\012", 1);
    }
    else
    {
        fprintf (stderr, "server doesn't support gzip-file-contents\n");
        gzip_level = 0;
    }
    }

#ifdef FILENAMES_CASE_INSENSITIVE
    if (supported_request ("Case"))
    send_to_server ("Case\012", 0);
#endif

    /* If "Set" is not supported, just silently fail to send the variables.
       Users with an old server should get a useful error message when it
       fails to recognize the ${=foo} syntax.  This way if someone uses
       several servers, some of which are new and some old, they can still
       set user variables in their .cvsrc without trouble.  */
    if (supported_request ("Set"))
    walklist (variable_list, send_variable_proc, NULL);
}

#ifndef RSH_NOT_TRANSPARENT
/* Contact the server by starting it with rsh.  */

/* Right now, we have two different definitions for this function,
   depending on whether we start the rsh server using popenRW or not.
   This isn't ideal, and the best thing would probably be to change
   the OS/2 port to be more like the regular Unix client (i.e., by
   implementing piped_child)... but I'm doing something else at the
   moment, and wish to make only one change at a time.  -Karl */

#ifdef START_RSH_WITH_POPEN_RW

/* This is actually a crock -- it's OS/2-specific, for no one else
   uses it.  If I get time, I want to make piped_child and all the
   other stuff in os2/run.c work right.  In the meantime, this gets us
   up and running, and that's most important. */

static void
start_rsh_server (tofdp, fromfdp)
     int *tofdp, *fromfdp;
{
  int pipes[2];

  /* If you're working through firewalls, you can set the
     CVS_RSH environment variable to a script which uses rsh to
     invoke another rsh on a proxy machine.  */
  char *cvs_rsh = getenv ("CVS_RSH");
  char *cvs_server = getenv ("CVS_SERVER");
  char command[PATH_MAX];
  int i = 0;
  /* This needs to fit "rsh", "-b", "-l", "USER", "host",
     "cmd (w/ args)", and NULL.  We leave some room to grow. */
  char *rsh_argv[10];

  if (!cvs_rsh)
    cvs_rsh = "rsh";
  if (!cvs_server)
    cvs_server = "cvs";

  /* If you are running a very old (Nov 3, 1994, before 1.5)
   * version of the server, you need to make sure that your .bashrc
   * on the server machine does not set CVSROOT to something
   * containing a colon (or better yet, upgrade the server).  */

  /* The command line starts out with rsh. */
  rsh_argv[i++] = cvs_rsh;

#ifdef RSH_NEEDS_BINARY_FLAG
  /* "-b" for binary, under OS/2. */
  rsh_argv[i++] = "-b";
#endif /* RSH_NEEDS_BINARY_FLAG */

  /* Then we strcat more things on the end one by one. */
  if (server_user != NULL)
    {
      rsh_argv[i++] = "-l";
      rsh_argv[i++] = server_user;
    }

  rsh_argv[i++] = server_host;
  rsh_argv[i++] = cvs_server;
  rsh_argv[i++] = "server";

  /* Mark the end of the arg list. */
  rsh_argv[i]   = (char *) NULL;

  if (trace)
    {
      fprintf (stderr, " -> Starting server: ");
      fprintf (stderr, "%s", command);
      putc ('\n', stderr);
    }

  /* Do the deed. */
  rsh_pid = popenRW (rsh_argv, pipes);
  if (rsh_pid < 0)
    error (1, errno, "cannot start server via rsh");

  /* Give caller the file descriptors. */
  *tofdp   = pipes[0];
  *fromfdp = pipes[1];
}

#else /* ! START_RSH_WITH_POPEN_RW */

static void
start_rsh_server (tofdp, fromfdp)
     int *tofdp;
     int *fromfdp;
{
    /* If you're working through firewalls, you can set the
       CVS_RSH environment variable to a script which uses rsh to
       invoke another rsh on a proxy machine.  */
    char *cvs_rsh = getenv ("CVS_RSH");
    char *cvs_server = getenv ("CVS_SERVER");
    char *command;

    if (!cvs_rsh)
    cvs_rsh = "rsh";
    if (!cvs_server)
    cvs_server = "cvs";

    /* Pass the command to rsh as a single string.  This shouldn't
       affect most rsh servers at all, and will pacify some buggy
       versions of rsh that grab switches out of the middle of the
       command (they're calling the GNU getopt routines incorrectly).  */
    command = xmalloc (strlen (cvs_server)
               + strlen (server_cvsroot)
               + 50);

    /* If you are running a very old (Nov 3, 1994, before 1.5)
     * version of the server, you need to make sure that your .bashrc
     * on the server machine does not set CVSROOT to something
     * containing a colon (or better yet, upgrade the server).  */
    sprintf (command, "%s server", cvs_server);

    {
        char *argv[10];
    char **p = argv;

    *p++ = cvs_rsh;
    *p++ = server_host;

    /* If the login names differ between client and server
     * pass it on to rsh.
     */
    if (server_user != NULL)
    {
        *p++ = "-l";
        *p++ = server_user;
    }

    *p++ = command;
    *p++ = NULL;

    if (trace)
        {
        int i;

            fprintf (stderr, " -> Starting server: ");
        for (i = 0; argv[i]; i++)
            fprintf (stderr, "%s ", argv[i]);
        putc ('\n', stderr);
    }
    rsh_pid = piped_child (argv, tofdp, fromfdp);

    if (rsh_pid < 0)
        error (1, errno, "cannot start server via rsh");
    }
}

#endif /* START_RSH_WITH_POPEN_RW */
#endif /* ! RSH_NOT_TRANSPARENT */



/* Send an argument STRING.  */
void
send_arg (string)
    char *string;
{
    char buf[1];
    char *p = string;

    send_to_server ("Argument ", 0);

    while (*p)
    {
    if (*p == '\n')
    {
        send_to_server ("\012Argumentx ", 0);
    }
    else
        {
        buf[0] = *p;
        send_to_server (buf, 1);
        }
    ++p;
    }
    send_to_server ("\012", 1);
}

static void send_modified PROTO ((char *, char *, Vers_TS *));

static void
send_modified (file, short_pathname, vers)
    char *file;
    char *short_pathname;
    Vers_TS *vers;
{
    /* File was modified, send it.  */
    struct stat sb;
    int fd;
    char *buf;
    char *mode_string;
    int bufsize;
    int bin;

    /* Don't think we can assume fstat exists.  */
    if (stat (file, &sb) < 0)
    error (1, errno, "reading %s", short_pathname);

    mode_string = mode_to_string (sb.st_mode);

    /* Beware: on systems using CRLF line termination conventions,
       the read and write functions will convert CRLF to LF, so the
       number of characters read is not the same as sb.st_size.  Text
       files should always be transmitted using the LF convention, so
       we don't want to disable this conversion.  */
    bufsize = sb.st_size;
    buf = xmalloc (bufsize);

    /* Is the file marked as containing binary data by the "-kb" flag?
       If so, make sure to open it in binary mode: */

    if (vers && vers->options)
      bin = !(strcmp (vers->options, "-kb"));
    else
      bin = 0;

    fd = open (file, O_RDONLY | (bin ? OPEN_BINARY : 0));

    if (fd < 0)
    error (1, errno, "reading %s", short_pathname);

    if (gzip_level && sb.st_size > 100)
    {
    int nread, newsize = 0, gzip_status;
    pid_t gzip_pid;
    char *bufp = buf;
    int readsize = 8192;
#ifdef LINES_CRLF_TERMINATED
    char tempfile[L_tmpnam];
    int converting;
#endif /* LINES_CRLF_TERMINATED */

#ifdef LINES_CRLF_TERMINATED
    /* Assume everything in a "cvs import" is text.  */
    if (vers == NULL)
        converting = 1;
    else
            /* Otherwise, we convert things unless they're binary. */
        converting = (! bin);

    if (converting)
    {
        /* gzip reads and writes files without munging CRLF
           sequences, as it should, but files should be
           transmitted in LF form.  Convert CRLF to LF before
           gzipping, on systems where this is necessary.

           If Windows NT supported fork, we could do this by
           pushing another filter on in front of gzip.  But it
           doesn't.  I'd have to write a trivial little program to
           do the conversion and have CVS spawn it off.  But
           little executables like that always get lost.

           Alternatively, this cruft could go away if we switched
           to a gzip library instead of a subprocess; then we
           could tell gzip to open the file with CRLF translation
           enabled.  */
        if (close (fd) < 0)
        error (0, errno, "warning: can't close %s", short_pathname);

        tmpnam (tempfile);
        convert_file (file, O_RDONLY,
              tempfile,
              O_WRONLY | O_CREAT | O_TRUNC | OPEN_BINARY);

        /* This OPEN_BINARY doesn't make any difference, I think, because
           gzip will deal with the inherited handle as it pleases.  But I
           do remember something obscure in the manuals about propagating
           the translation mode to created processes via environment
           variables, ick.  */
        fd = open (tempfile, O_RDONLY | OPEN_BINARY);
        if (fd < 0)
        error (1, errno, "reading %s", short_pathname);
    }
#endif /* LINES_CRLF_TERMINATED */

    fd = filter_through_gzip (fd, 1, gzip_level, &gzip_pid);

    /* FIXME: is there any reason to go through all this realloc'ing
       when we could just be writing the data to the network as we read
       it from gzip?  */
    while (1)
    {
        if ((bufp - buf) + readsize >= bufsize)
        {
        /*
         * We need to expand the buffer if gzip ends up expanding
         * the file.
         */
        newsize = bufp - buf;
        while (newsize + readsize >= bufsize)
          bufsize *= 2;
        buf = xrealloc (buf, bufsize);
        bufp = buf + newsize;
        }
        nread = read (fd, bufp, readsize);
        if (nread < 0)
        error (1, errno, "reading from gzip pipe");
        else if (nread == 0)
        /* eof */
        break;
        bufp += nread;
    }
    newsize = bufp - buf;
    if (close (fd) < 0)
        error (0, errno, "warning: can't close %s", short_pathname);

    if (waitpid (gzip_pid, &gzip_status, 0) != gzip_pid)
        error (1, errno, "waiting for gzip proc %ld", (long) gzip_pid);
    else if (gzip_status != 0)
        error (1, errno, "gzip exited %d", gzip_status);

#if LINES_CRLF_TERMINATED
    if (converting)
    {
        if (unlink (tempfile) < 0)
        error (0, errno,
               "warning: can't remove temp file %s", tempfile);
    }
#endif /* LINES_CRLF_TERMINATED */

        {
          char tmp[80];

      send_to_server ("Modified ", 0);
      send_to_server (file, 0);
      send_to_server ("\012", 1);
      send_to_server (mode_string, 0);
      send_to_server ("\012z", 2);
      sprintf (tmp, "%lu\n", (unsigned long) newsize);
      send_to_server (tmp, 0);

          send_to_server (buf, newsize);
        }
    }
    else
    {
        int newsize;

        {
        char *bufp = buf;
        int len;

        /* FIXME: This is gross.  It assumes that we might read
           less than st_size bytes (true on NT), but not more.
           Instead of this we should just be reading a block of
           data (e.g. 8192 bytes), writing it to the network, and
           so on until EOF.  */
        while ((len = read (fd, bufp, (buf + sb.st_size) - bufp)) > 0)
            bufp += len;

        if (len < 0)
            error (1, errno, "reading %s", short_pathname);

        newsize = bufp - buf;
    }
    if (close (fd) < 0)
        error (0, errno, "warning: can't close %s", short_pathname);

        {
          char tmp[80];

      send_to_server ("Modified ", 0);
      send_to_server (file, 0);
      send_to_server ("\012", 1);
      send_to_server (mode_string, 0);
      send_to_server ("\012", 1);
          sprintf (tmp, "%lu\012", (unsigned long) newsize);
          send_to_server (tmp, 0);
        }

    /*
     * Note that this only ends with a newline if the file ended with
     * one.
     */
    if (newsize > 0)
          send_to_server (buf, newsize);
    }
    free (buf);
    free (mode_string);
}

static int send_fileproc PROTO ((struct file_info *finfo));

/* Deal with one file.  */
static int
send_fileproc (finfo)
    struct file_info *finfo;
{
    Vers_TS *vers;

    send_a_repository ("", finfo->repository, finfo->update_dir);

    vers = Version_TS ((char *)NULL, (char *)NULL, (char *)NULL,
               (char *)NULL,
               finfo->file, 0, 0, finfo->entries, (RCSNode *)NULL);

    if (vers->vn_user != NULL)
    {
      char *tmp;

      tmp = xmalloc (strlen (finfo->file) + strlen (vers->vn_user)
             + strlen (vers->options) + 200);
      sprintf (tmp, "Entry /%s/%s/%s%s/%s/",
               finfo->file, vers->vn_user,
               vers->ts_conflict == NULL ? "" : "+",
               (vers->ts_conflict == NULL ? ""
                : (vers->ts_user != NULL &&
                   strcmp (vers->ts_conflict, vers->ts_user) == 0
                   ? "="
                   : "modified")),
               vers->options);

    /* The Entries request.  */
    /* Not sure about whether this deals with -k and stuff right.  */
    send_to_server (tmp, 0);
        free (tmp);
    if (vers->entdata != NULL && vers->entdata->tag)
    {
        send_to_server ("T", 0);
        send_to_server (vers->entdata->tag, 0);
    }
    else if (vers->entdata != NULL && vers->entdata->date)
          {
        send_to_server ("D", 0);
        send_to_server (vers->entdata->date, 0);
          }
    send_to_server ("\012", 1);
    }

    if (vers->ts_user == NULL)
    {
    /*
     * Do we want to print "file was lost" like normal CVS?
     * Would it always be appropriate?
     */
    /* File no longer exists.  */
    if (!use_unchanged)
    {
        /* if the server is old, use the old request... */
        send_to_server ("Lost ", 0);
        send_to_server (finfo->file, 0);
        send_to_server ("\012", 1);
        /*
         * Otherwise, don't do anything for missing files,
         * they just happen.
         */
    }
    }
    else if (vers->ts_rcs == NULL
         || strcmp (vers->ts_user, vers->ts_rcs) != 0)
    {
    send_modified (finfo->file, finfo->fullname, vers);
    }
    else
    {
    /* Only use this request if the server supports it... */
    if (use_unchanged)
          {
        send_to_server ("Unchanged ", 0);
        send_to_server (finfo->file, 0);
        send_to_server ("\012", 1);
          }
    }

    /* if this directory has an ignore list, add this file to it */
    if (ignlist)
    {
    Node *p;

    p = getnode ();
    p->type = FILES;
    p->key = xstrdup (finfo->file);
    (void) addnode (ignlist, p);
    }

    freevers_ts (&vers);
    return 0;
}

static void send_ignproc PROTO ((char *, char *));

static void
send_ignproc (file, dir)
    char *file;
    char *dir;
{
    if (ign_inhibit_server || !supported_request ("Questionable"))
    {
    if (dir[0] != '\0')
        (void) printf ("? %s/%s\n", dir, file);
    else
        (void) printf ("? %s\n", file);
    }
    else
    {
    send_to_server ("Questionable ", 0);
    send_to_server (file, 0);
    send_to_server ("\012", 1);
    }
}

static int send_filesdoneproc PROTO ((int, char *, char *));

static int
send_filesdoneproc (err, repository, update_dir)
    int err;
    char *repository;
    char *update_dir;
{
    /* if this directory has an ignore list, process it then free it */
    if (ignlist)
    {
    ignore_files (ignlist, update_dir, send_ignproc);
    dellist (&ignlist);
    }

    return (err);
}

static Dtype send_dirent_proc PROTO ((char *, char *, char *));

/*
 * send_dirent_proc () is called back by the recursion processor before a
 * sub-directory is processed for update.
 * A return code of 0 indicates the directory should be
 * processed by the recursion code.  A return of non-zero indicates the
 * recursion code should skip this directory.
 *
 */
static Dtype
send_dirent_proc (dir, repository, update_dir)
    char *dir;
    char *repository;
    char *update_dir;
{
    int dir_exists;
    char *cvsadm_repos_name;

    /*
     * If the directory does not exist yet (e.g. "cvs update -d
     * foo"), no need to send any files from it.
     */
    dir_exists = isdir (dir);

    if (ignore_directory (update_dir))
    {
    /* print the warm fuzzy message */
    if (!quiet)
        error (0, 0, "Ignoring %s", update_dir);
        return (R_SKIP_ALL);
    }

    /* initialize the ignore list for this directory */
    ignlist = getlist ();

    /*
     * If there is an empty directory (e.g. we are doing `cvs add' on a
     * newly-created directory), the server still needs to know about it.
     */

    cvsadm_repos_name = xmalloc (strlen (dir) + sizeof (CVSADM_REP) + 80);
    sprintf (cvsadm_repos_name, "%s/%s", dir, CVSADM_REP);
    if (dir_exists && isreadable (cvsadm_repos_name))
    {
    /*
     * Get the repository from a CVS/Repository file whenever possible.
     * The repository variable is wrong if the names in the local
     * directory don't match the names in the repository.
     */
    char *repos = Name_Repository (dir, update_dir);
    send_a_repository (dir, repos, update_dir);
    free (repos);
    }
    else
    send_a_repository (dir, repository, update_dir);
    free (cvsadm_repos_name);

    return (dir_exists ? R_PROCESS : R_SKIP_ALL);
}

/*
 * Send each option in a string to the server, one by one.
 * This assumes that the options are single characters.  For
 * more complex parsing, do it yourself.
 */

void
send_option_string (string)
    char *string;
{
    char *p;
    char it[3];

    for (p = string; p[0]; p++) {
    if (p[0] == ' ')
        continue;
    if (p[0] == '-')
        continue;
    it[0] = '-';
    it[1] = p[0];
    it[2] = '\0';
    send_arg (it);
    }
}


/* Send the names of all the argument files to the server.  */

void
send_file_names (argc, argv, flags)
    int argc;
    char **argv;
    unsigned int flags;
{
    int i;
    char *p;
    char *q;
    int level;
    int max_level;

    /* The fact that we do this here as well as start_recursion is a bit
       of a performance hit.  Perhaps worth cleaning up someday.  */
    if (flags & SEND_EXPAND_WILD)
    expand_wild (argc, argv, &argc, &argv);

    /* Send Max-dotdot if needed.  */
    max_level = 0;
    for (i = 0; i < argc; ++i)
    {
    p = argv[i];
    level = 0;
    do
    {
        q = strchr (p, '/');
        if (q != NULL)
        ++q;
        if (p[0] == '.' && p[1] == '.' && (p[2] == '\0' || p[2] == '/'))
        {
        --level;
        if (-level > max_level)
            max_level = -level;
        }
        else if (p[0] == '.' && (p[1] == '\0' || p[1] == '/'))
        ;
        else
        ++level;
        p = q;
    } while (p != NULL);
    }
    if (max_level > 0)
    {
    if (supported_request ("Max-dotdot"))
    {
            char buf[10];
            sprintf (buf, "%d", max_level);

        send_to_server ("Max-dotdot ", 0);
        send_to_server (buf, 0);
        send_to_server ("\012", 1);
    }
    else
        /*
         * "leading .." is not strictly correct, as this also includes
         * cases like "foo/../..".  But trying to explain that in the
         * error message would probably just confuse users.
         */
        error (1, 0,
           "leading .. not supported by old (pre-Max-dotdot) servers");
    }

    for (i = 0; i < argc; ++i)
    {
    char buf[1];
    char *p = argv[i];

    send_to_server ("Argument ", 0);

    while (*p)
    {
        if (*p == '\n')
        {
        send_to_server ("\012Argumentx ", 0);
        }
        else if (ISDIRSEP (*p))
        {
        buf[0] = '/';
        send_to_server (buf, 1);
        }
        else
        {
        buf[0] = *p;
        send_to_server (buf, 1);
        }
        ++p;
    }
    send_to_server ("\012", 1);
    }

    if (flags & SEND_EXPAND_WILD)
    {
    int i;
    for (i = 0; i < argc; ++i)
        free (argv[i]);
    free (argv);
    }
}


/*
 * Send Repository, Modified and Entry.  argc and argv contain only
 * the files to operate on (or empty for everything), not options.
 * local is nonzero if we should not recurse (-l option).  Also sends
 * Argument lines for argc and argv, so should be called after options
 * are sent.
 */
void
send_files (argc, argv, local, aflag)
    int argc;
    char **argv;
    int local;
    int aflag;
{
    int err;

    /*
     * aflag controls whether the tag/date is copied into the vers_ts.
     * But we don't actually use it, so I don't think it matters what we pass
     * for aflag here.
     */
    err = start_recursion
    (send_fileproc, send_filesdoneproc,
     send_dirent_proc, (DIRLEAVEPROC)NULL,
     argc, argv, local, W_LOCAL, aflag, 0, (char *)NULL, 0, 0);
    if (err)
    exit (EXIT_FAILURE);
    if (toplevel_repos == NULL)
    /*
     * This happens if we are not processing any files,
     * or for checkouts in directories without any existing stuff
     * checked out.  The following assignment is correct for the
     * latter case; I don't think toplevel_repos matters for the
     * former.
     */
    toplevel_repos = xstrdup (server_cvsroot);
    send_repository ("", toplevel_repos, ".");
}

void
client_import_setup (repository)
    char *repository;
{
    if (toplevel_repos == NULL)        /* should always be true */
        send_a_repository ("", repository, "");
}

/*
 * Process the argument import file.
 */
int
client_process_import_file (message, vfile, vtag, targc, targv, repository)
    char *message;
    char *vfile;
    char *vtag;
    int targc;
    char *targv[];
    char *repository;
{
    char *short_pathname;
    int first_time;

    /* FIXME: I think this is always false now that we call
       client_import_setup at the start.  */

    first_time = toplevel_repos == NULL;

    if (first_time)
    send_a_repository ("", repository, "");

    if (strncmp (repository, toplevel_repos, strlen (toplevel_repos)) != 0)
    error (1, 0,
           "internal error: pathname `%s' doesn't specify file in `%s'",
           repository, toplevel_repos);
    short_pathname = repository + strlen (toplevel_repos) + 1;

    if (!first_time)
    {
    send_a_repository ("", repository, short_pathname);
    }
    send_modified (vfile, short_pathname, NULL);
    return 0;
}

void
client_import_done ()
{
    if (toplevel_repos == NULL)
    /*
     * This happens if we are not processing any files,
     * or for checkouts in directories without any existing stuff
     * checked out.  The following assignment is correct for the
     * latter case; I don't think toplevel_repos matters for the
     * former.
     */
        /* FIXME: "can't happen" now that we call client_import_setup
       at the beginning.  */
    toplevel_repos = xstrdup (server_cvsroot);
    send_repository ("", toplevel_repos, ".");
}

static void
notified_a_file (data, ent_list, short_pathname, filename)
    char *data;
    List *ent_list;
    char *short_pathname;
    char *filename;
{
    FILE *fp;
    FILE *newf;
    size_t line_len = 8192;
    char *line = xmalloc (line_len);
    char *cp;
    int nread;
    int nwritten;
    char *p;

    fp = open_file (CVSADM_NOTIFY, "r");
    if (getline (&line, &line_len, fp) < 0)
    {
    error (0, errno, "cannot read %s", CVSADM_NOTIFY);
    goto error_exit;
    }
    cp = strchr (line, '\t');
    if (cp == NULL)
    {
    error (0, 0, "malformed %s file", CVSADM_NOTIFY);
    goto error_exit;
    }
    *cp = '\0';
    if (strcmp (filename, line + 1) != 0)
    {
    error (0, 0, "protocol error: notified %s, expected %s", filename,
           line + 1);
    }

    if (getline (&line, &line_len, fp) < 0)
    {
    if (feof (fp))
    {
        if (fclose (fp) < 0)
        error (0, errno, "cannot close %s", CVSADM_NOTIFY);
        if (unlink (CVSADM_NOTIFY) < 0)
        error (0, errno, "cannot remove %s", CVSADM_NOTIFY);
        return;
    }
    else
    {
        error (0, errno, "cannot read %s", CVSADM_NOTIFY);
        goto error_exit;
    }
    }
    newf = open_file (CVSADM_NOTIFYTMP, "w");
    if (fputs (line, newf) < 0)
    {
    error (0, errno, "cannot write %s", CVSADM_NOTIFYTMP);
    goto error2;
    }
    while ((nread = fread (line, 1, line_len, fp)) > 0)
    {
    p = line;
    while ((nwritten = fwrite (p, 1, nread, newf)) > 0)
    {
        nread -= nwritten;
        p += nwritten;
    }
    if (ferror (newf))
    {
        error (0, errno, "cannot write %s", CVSADM_NOTIFYTMP);
        goto error2;
    }
    }
    if (ferror (fp))
    {
    error (0, errno, "cannot read %s", CVSADM_NOTIFY);
    goto error2;
    }
    if (fclose (newf) < 0)
    {
    error (0, errno, "cannot close %s", CVSADM_NOTIFYTMP);
    goto error_exit;
    }
    if (fclose (fp) < 0)
    {
    error (0, errno, "cannot close %s", CVSADM_NOTIFY);
    return;
    }

    {
        /* In this case, we want rename_file() to ignore noexec. */
        int saved_noexec = noexec;
        noexec = 0;
        rename_file (CVSADM_NOTIFYTMP, CVSADM_NOTIFY);
        noexec = saved_noexec;
    }

    return;
  error2:
    (void) fclose (newf);
  error_exit:
    (void) fclose (fp);
}

static void
handle_notified (args, len)
    char *args;
    int len;
{
    call_in_directory (args, notified_a_file, NULL);
}

void
client_notify (repository, update_dir, filename, notif_type, val)
    char *repository;
    char *update_dir;
    char *filename;
    int notif_type;
    char *val;
{
    char buf[2];

    send_a_repository ("", repository, update_dir);
    send_to_server ("Notify ", 0);
    send_to_server (filename, 0);
    send_to_server ("\012", 1);
    buf[0] = notif_type;
    buf[1] = '\0';
    send_to_server (buf, 1);
    send_to_server ("\t", 1);
    send_to_server (val, 0);
}

/*
 * Send an option with an argument, dealing correctly with newlines in
 * the argument.  If ARG is NULL, forget the whole thing.
 */
void
option_with_arg (option, arg)
    char *option;
    char *arg;
{
    if (arg == NULL)
    return;

    send_to_server ("Argument ", 0);
    send_to_server (option, 0);
    send_to_server ("\012", 1);

    send_arg (arg);
}

/*
 * Send a date to the server.  This will passed a string which is the
 * result of Make_Date, and looks like YY.MM.DD.HH.MM.SS, where all
 * the letters are single digits.  The time will be GMT.  getdate on
 * the server can't parse that, so we turn it back into something
 * which it can parse.
 */

void
client_senddate (date)
    const char *date;
{
    int year, month, day, hour, minute, second;
    char buf[100];

    if (sscanf (date, DATEFORM, &year, &month, &day, &hour, &minute, &second)
    != 6)
    {
        error (1, 0, "diff_client_senddate: sscanf failed on date");
    }

#ifndef HAVE_RCS5
    /* We need to fix the timezone in this case; see Make_Date.  */
    abort ();
#endif /* HAVE_RCS5 */

    sprintf (buf, "%d/%d/%d %d:%d:%d GMT", month, day, year,
         hour, minute, second);
    option_with_arg ("-D", buf);
}

int
client_commit (argc, argv)
    int argc;
    char **argv;
{
    parse_cvsroot ();

    return commit (argc, argv);
}

int
client_update (argc, argv)
    int argc;
    char **argv;
{
    parse_cvsroot ();

    return update (argc, argv);
}

int
client_checkout (argc, argv)
    int argc;
    char **argv;
{
    parse_cvsroot ();

    return checkout (argc, argv);
}

int
client_diff (argc, argv)
    int argc;
    char **argv;
{
    parse_cvsroot ();

    return diff (argc, argv);    /* Call real code */
}

int
client_status (argc, argv)
    int argc;
    char **argv;
{
    parse_cvsroot ();
    return status (argc, argv);
}

int
client_log (argc, argv)
    int argc;
    char **argv;
{

    parse_cvsroot ();

    return cvslog (argc, argv);    /* Call real code */
}

int
client_add (argc, argv)
    int argc;
    char **argv;
{

    parse_cvsroot ();

    return add (argc, argv);    /* Call real code */
}

int
client_remove (argc, argv)
    int argc;
    char **argv;
{

    parse_cvsroot ();

    return cvsremove (argc, argv);    /* Call real code */
}

int
client_rdiff (argc, argv)
    int argc;
    char **argv;
{

    parse_cvsroot ();

    return patch (argc, argv);    /* Call real code */
}

int
client_tag (argc, argv)
    int argc;
    char **argv;
{

    parse_cvsroot ();

    return tag (argc, argv);    /* Call real code */
}

int
client_rtag (argc, argv)
    int argc;
    char **argv;
{

    parse_cvsroot ();

    return rtag (argc, argv);    /* Call real code */
}

int
client_import (argc, argv)
    int argc;
    char **argv;
{

    parse_cvsroot ();

    return import (argc, argv);    /* Call real code */
}

int
client_admin (argc, argv)
    int argc;
    char **argv;
{

    parse_cvsroot ();

    return admin (argc, argv);    /* Call real code */
}

int
client_export (argc, argv)
    int argc;
    char **argv;
{

    parse_cvsroot ();

    return checkout (argc, argv);    /* Call real code */
}

int
client_history (argc, argv)
    int argc;
    char **argv;
{

    parse_cvsroot ();

    return history (argc, argv);    /* Call real code */
}

int
client_release (argc, argv)
    int argc;
    char **argv;
{

    parse_cvsroot ();

    return release (argc, argv);    /* Call real code */
}

int
client_watch (argc, argv)
    int argc;
    char **argv;
{

    parse_cvsroot ();

    return watch (argc, argv);    /* Call real code */
}

int
client_watchers (argc, argv)
    int argc;
    char **argv;
{

    parse_cvsroot ();

    return watchers (argc, argv);    /* Call real code */
}

int
client_editors (argc, argv)
    int argc;
    char **argv;
{

    parse_cvsroot ();

    return editors (argc, argv);    /* Call real code */
}

int
client_edit (argc, argv)
    int argc;
    char **argv;
{

    parse_cvsroot ();

    return edit (argc, argv);    /* Call real code */
}

int
client_unedit (argc, argv)
    int argc;
    char **argv;
{

    parse_cvsroot ();

    return unedit (argc, argv);    /* Call real code */
}

void
send_init_command ()
{
    /* This is here because we need the server_cvsroot variable.  */
    send_to_server ("init ", 0);
    send_to_server (server_cvsroot, 0);
    send_to_server ("\012", 0);
}

int
client_init (argc, argv)
    int argc;
    char **argv;
{
    parse_cvsroot ();

    return init (argc, argv);    /* Call real code */
}

int
client_annotate (argc, argv)
    int argc;
    char **argv;
{
    parse_cvsroot ();

    return annotate (argc, argv);    /* Call real code */
}
#endif /* CLIENT_SUPPORT */